コード例 #1
0
  /**
   * @see
   *     PatientDataEvaluator#evaluate(org.openmrs.module.reporting.data.patient.definition.PatientDataDefinition,
   *     org.openmrs.module.reporting.evaluation.EvaluationContext)
   */
  public EvaluatedPatientData evaluate(PatientDataDefinition definition, EvaluationContext context)
      throws EvaluationException {

    CalculationDataDefinition def = (CalculationDataDefinition) definition;
    EvaluatedPatientData c = new EvaluatedPatientData(def, context);

    // return right away if there is nothing to evaluate
    if (context.getBaseCohort() != null && context.getBaseCohort().isEmpty()) {
      return c;
    }

    // evaluate the calculation
    PatientCalculationService service = Context.getService(PatientCalculationService.class);
    CalculationResultMap resultMap =
        service.evaluate(
            context.getBaseCohort().getMemberIds(),
            def.getCalculation(),
            def.getCalculationParameters(),
            context);

    // move data into return object
    for (Map.Entry<Integer, CalculationResult> entry : resultMap.entrySet()) {
      c.addData(entry.getKey(), entry.getValue());
    }

    return c;
  }
コード例 #2
0
  @Override
  public CalculationResultMap evaluate(
      Collection<Integer> cohort, Map<String, Object> map, PatientCalculationContext context) {
    CalculationResultMap ret = new CalculationResultMap();
    PersonService personService = Context.getPersonService();
    PersonAttributeType personAttributeType =
        personService.getPersonAttributeTypeByUuid(
            CommonMetadata._PersonAttributeType.TELEPHONE_CONTACT);

    PersonAttributeCohortDefinition cd = new PersonAttributeCohortDefinition();
    cd.setAttributeType(personAttributeType);

    EvaluatedCohort peopleWithPhoneNumbersCohort =
        CalculationUtils.evaluateWithReporting(cd, cohort, null, context);

    PersonAttributeDataDefinition personAttributeDataDefinition =
        new PersonAttributeDataDefinition();
    personAttributeDataDefinition.setPersonAttributeType(personAttributeType);

    CalculationResultMap data =
        CalculationUtils.evaluateWithReporting(
            personAttributeDataDefinition, cohort, map, null, context);

    for (Integer ptId : cohort) {
      String phoneNumber = null;
      if (peopleWithPhoneNumbersCohort.contains(ptId)) {
        phoneNumber = data.get(ptId).toString();
      }
      ret.put(ptId, new SimpleResult(phoneNumber, this));
    }
    return ret;
  }
  @Test
  public void evaluate_shouldReturnHivPatientsNotScreenedForTb() throws Exception {

    // Get HIV Program and TB screening encounter type
    Program hivProgram = MetadataUtils.getProgram(Metadata.HIV_PROGRAM);
    EncounterType screeningEncType =
        MetadataUtils.getEncounterType(Metadata.TB_SCREENING_ENCOUNTER_TYPE);

    // Enroll patients #6 and #7
    PatientService ps = Context.getPatientService();
    TestUtils.enrollInProgram(ps.getPatient(6), hivProgram, TestUtils.date(2011, 1, 1));
    TestUtils.enrollInProgram(ps.getPatient(7), hivProgram, TestUtils.date(2011, 1, 1));

    // Screen patient #6 for TB a year later
    TestUtils.saveEncounter(ps.getPatient(6), screeningEncType, TestUtils.date(2012, 1, 1));

    Context.flushSession();

    List<Integer> cohort = Arrays.asList(6, 7, 8);
    CalculationResultMap resultMap =
        Context.getService(PatientCalculationService.class)
            .evaluate(cohort, new NeverScreenedForTbCalculation());
    Assert.assertFalse((Boolean) resultMap.get(6).getValue());
    Assert.assertTrue((Boolean) resultMap.get(7).getValue());
    Assert.assertNull(resultMap.get(8)); // not in HIV program
  }
  /**
   * @see org.openmrs.calculation.patient.PatientCalculation#evaluate(java.util.Collection,
   *     java.util.Map, org.openmrs.calculation.patient.PatientCalculationContext)
   */
  @Override
  public CalculationResultMap evaluate(
      Collection<Integer> cohort,
      Map<String, Object> parameterValues,
      PatientCalculationContext context) {

    Program mchcsProgram = MetadataUtils.getProgram(MchMetadata._Program.MCHCS);

    // Get all patients who are alive and in MCH-CS program
    Set<Integer> alive = Filters.alive(cohort, context);
    Set<Integer> inMchcsProgram = Filters.inProgram(mchcsProgram, alive, context);

    // get wheather the child is HIV Exposed
    CalculationResultMap lastChildHivStatus =
        Calculations.lastObs(
            Dictionary.getConcept(Dictionary.CHILDS_CURRENT_HIV_STATUS), inMchcsProgram, context);
    CalculationResultMap medOrdersObss =
        Calculations.allObs(Dictionary.getConcept(Dictionary.MEDICATION_ORDERS), cohort, context);

    // Get concepts for  medication prophylaxis
    Concept nvp = Dictionary.getConcept(Dictionary.NEVIRAPINE);
    Concept nvpazt3tc = Dictionary.getConcept(Dictionary.LAMIVUDINE_NEVIRAPINE_ZIDOVUDINE);
    Concept hivExposed = Dictionary.getConcept(Dictionary.EXPOSURE_TO_HIV);

    CalculationResultMap ret = new CalculationResultMap();

    for (Integer ptId : cohort) {
      boolean notOnPcp = false;

      // checking wheather the infant is in mchcs program, alive and HEI
      Obs hivStatusObs = EmrCalculationUtils.obsResultForPatient(lastChildHivStatus, ptId);
      if (inMchcsProgram.contains(ptId)
          && lastChildHivStatus != null
          && hivStatusObs != null
          && (hivStatusObs.getValueCoded().equals(hivExposed))) {
        notOnPcp = true;
        ListResult patientMedOrders = (ListResult) medOrdersObss.get(ptId);
        if (patientMedOrders != null) {
          // Look through list of medication order obs for any  CTX
          List<Obs> medOrderObsList = CalculationUtils.extractResultValues(patientMedOrders);
          for (Obs medOrderObs : medOrderObsList) {
            if (medOrderObs.getValueCoded().equals(nvp)
                || medOrderObs.getValueCoded().equals(nvpazt3tc)) {
              notOnPcp = false;
              break;
            }
          }
        }
      }
      ret.put(ptId, new BooleanResult(notOnPcp, this, context));
    }

    return ret;
  }
  /**
   * @see
   *     org.openmrs.module.kenyaemr.calculation.library.hiv.MissedAppointmentsOrDefaultedCalculation#evaluate(java.util.Collection,
   *     java.util.Map, org.openmrs.calculation.patient.PatientCalculationContext)
   * @verifies determine whether patients have a Missed appointments or defaulted
   */
  @Test
  public void evaluate_shouldDetermineWhetherPatientsWhoMissedAppointmentsOrDefaulted()
      throws Exception {

    // Get HIV Program
    Program hivProgram = MetadataUtils.getProgram(Metadata.HIV_PROGRAM);

    // Enroll patients #6, #7, #8 in the HIV Program
    PatientService ps = Context.getPatientService();
    for (int i = 6; i <= 8; ++i) {
      TestUtils.enrollInProgram(ps.getPatient(i), hivProgram, TestUtils.date(2011, 1, 1));
    }

    // Give patient #7 a return visit obs of 10 days ago
    Concept returnVisit = Context.getConceptService().getConcept(5096);
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.DATE, -10);
    TestUtils.saveObs(
        Context.getPatientService().getPatient(7),
        returnVisit,
        calendar.getTime(),
        calendar.getTime());

    // Give patient #8 a return visit obs of 10 days in the future
    calendar = Calendar.getInstance();
    calendar.add(Calendar.DATE, 10);
    TestUtils.saveObs(
        Context.getPatientService().getPatient(8),
        returnVisit,
        calendar.getTime(),
        calendar.getTime());

    Context.flushSession();

    List<Integer> ptIds = Arrays.asList(6, 7, 8, 9);

    CalculationResultMap resultMap =
        new MissedAppointmentsOrDefaultedCalculation()
            .evaluate(
                ptIds,
                null,
                Context.getService(PatientCalculationService.class).createCalculationContext());
    Assert.assertFalse(
        (Boolean) resultMap.get(6).getValue()); // patient in HIV program but no return visit obs
    Assert.assertTrue((Boolean) resultMap.get(7).getValue()); // patient has missed visit
    Assert.assertFalse(
        (Boolean) resultMap.get(8).getValue()); // patient has future return visit date
    Assert.assertFalse((Boolean) resultMap.get(9).getValue()); // patient not in HIV Program
  }
  /**
   * @see VisitsOnDayCalculation#evaluate(java.util.Collection, java.util.Map,
   *     org.openmrs.calculation.patient.PatientCalculationContext)
   */
  @Test
  public void evaluate_shouldDefaultToToday() throws Exception {
    List<Integer> ptIds = Arrays.asList(7, 8);
    Map<String, Object> paramValues = new HashMap<String, Object>();

    CalculationResultMap resultMap =
        new VisitsOnDayCalculation()
            .evaluate(
                ptIds,
                paramValues,
                Context.getService(PatientCalculationService.class).createCalculationContext());

    Assert.assertThat(resultMap.get(7).isEmpty(), is(true)); // No visits on that day
    Assert.assertThat(resultMap.get(8).isEmpty(), is(true)); // No visits on that day
  }
コード例 #7
0
  /**
   * Evaluates the calculation
   *
   * @should calculate false for deceased patients
   * @should calculate false for patients not in HIV program
   * @should calculate false for patients with an encounter in last LOST_TO_FOLLOW_UP_THRESHOLD_DAYS
   *     days days since appointment date
   * @should calculate true for patient with no encounter in last LOST_TO_FOLLOW_UP_THRESHOLD_DAYS
   *     days days since appointment date
   */
  @Override
  public CalculationResultMap evaluate(
      Collection<Integer> cohort, Map<String, Object> arg1, PatientCalculationContext context) {

    Program hivProgram = MetadataUtils.existing(Program.class, HivMetadata._Program.HIV);
    Concept reasonForDiscontinuation =
        Dictionary.getConcept(Dictionary.REASON_FOR_PROGRAM_DISCONTINUATION);
    Concept transferout = Dictionary.getConcept(Dictionary.TRANSFERRED_OUT);

    Set<Integer> alive = Filters.alive(cohort, context);
    Set<Integer> inHivProgram = Filters.inProgram(hivProgram, alive, context);

    // CalculationResultMap lastEncounters = Calculations.lastEncounter(null, inHivProgram,
    // context);
    CalculationResultMap lastReturnDateObss =
        Calculations.lastObs(
            Dictionary.getConcept(Dictionary.RETURN_VISIT_DATE), inHivProgram, context);
    CalculationResultMap lastProgramDiscontinuation =
        Calculations.lastObs(reasonForDiscontinuation, cohort, context);

    CalculationResultMap ret = new CalculationResultMap();
    for (Integer ptId : cohort) {
      boolean lost = false;

      // Is patient alive and in the HIV program
      if (alive.contains(ptId)) {

        // Patient is lost if no encounters in last X days
        // Encounter lastEncounter = EmrCalculationUtils.encounterResultForPatient(lastEncounters,
        // ptId);
        Date lastScheduledReturnDate =
            EmrCalculationUtils.datetimeObsResultForPatient(lastReturnDateObss, ptId);
        Obs discontuation =
            EmrCalculationUtils.obsResultForPatient(lastProgramDiscontinuation, ptId);
        if (lastScheduledReturnDate != null) {
          if (daysSince(lastScheduledReturnDate, context)
              > HivConstants.LOST_TO_FOLLOW_UP_THRESHOLD_DAYS) {
            lost = true;
          }
          if (discontuation != null && discontuation.getValueCoded().equals(transferout)) {
            lost = false;
          }
        }
      }
      ret.put(ptId, new SimpleResult(lost, this, context));
    }
    return ret;
  }
コード例 #8
0
  @Test
  public void evaluate_shouldReturnTrueForAllAlivePatients() {

    // Mark patient #8 as deceased on 1st Jan 2012
    TestUtils.getPatient(8).setDead(true);
    TestUtils.getPatient(8).setDeathDate(TestUtils.date(2012, 1, 1));

    List<Integer> ptIds = Arrays.asList(2, 6, 7, 8);
    CalculationResultMap resultMap =
        Context.getService(PatientCalculationService.class)
            .evaluate(ptIds, new EligibleForTbProgramCalculation());
    Assert.assertTrue((Boolean) resultMap.get(2).getValue());
    Assert.assertTrue((Boolean) resultMap.get(6).getValue());
    Assert.assertTrue((Boolean) resultMap.get(7).getValue());
    Assert.assertFalse((Boolean) resultMap.get(8).getValue()); // Deceased
  }
  /**
   * @see VisitsOnDayCalculation#evaluate(java.util.Collection, java.util.Map,
   *     org.openmrs.calculation.patient.PatientCalculationContext)
   */
  @Test
  public void evaluate_shouldFetchAllPatientVisitsOnDate() throws Exception {
    List<Integer> ptIds = Arrays.asList(7, 8);
    Map<String, Object> paramValues = new HashMap<String, Object>();
    paramValues.put("date", TestUtils.date(2012, 1, 1));

    CalculationResultMap resultMap =
        new VisitsOnDayCalculation()
            .evaluate(
                ptIds,
                paramValues,
                Context.getService(PatientCalculationService.class).createCalculationContext());

    Assert.assertThat(((ListResult) resultMap.get(7)).getValues().size(), is(2)); // Has two visit
    Assert.assertThat(resultMap.get(8).isEmpty(), is(true)); // No visits on that day
  }
  @Override
  public CalculationResultMap evaluate(
      Collection<Integer> cohort,
      Map<String, Object> parameterValues,
      PatientCalculationContext context) {
    //		Date date = (Date) parameterValues.get("date");
    //		if (date == null) {
    //			date = new Date();
    //		}

    if (parameterValues != null) {
      logger.info("Parameter Values is NOT null");
      logger.info(parameterValues.toString());
    } else {

      logger.info("Parameter Values is null");
    }
    Date date = new Date();

    Date startOfDay = DateUtil.getStartOfDay(date);
    Date endOfDay = DateUtil.getEndOfDay(date);
    Concept returnVisitDate = Dictionary.getConcept(Dictionary.RETURN_VISIT_DATE);
    // EncounterType tbFollowup = MetadataUtils.existing(EncounterType.class,
    // TbMetadata._EncounterType.TB_CONSULTATION);

    DateObsCohortDefinition cd = new DateObsCohortDefinition();
    cd.setTimeModifier(TimeModifier.ANY);
    cd.setQuestion(returnVisitDate);
    cd.setOperator1(RangeComparator.GREATER_EQUAL);
    cd.setValue1(startOfDay);
    cd.setOperator2(RangeComparator.LESS_EQUAL);
    cd.setValue2(endOfDay);
    // cd.setEncounterTypeList(Collections.singletonList(tbFollowup));

    EvaluatedCohort withScheduledVisit =
        CalculationUtils.evaluateWithReporting(cd, cohort, null, context);

    CalculationResultMap ret = new CalculationResultMap();

    for (Integer ptId : cohort) {
      ret.put(ptId, new BooleanResult(withScheduledVisit.contains(ptId), this));
    }

    return ret;
  }
コード例 #11
0
 /**
  * @see org.openmrs.calculation.patient.PatientCalculation#evaluate(java.util.Collection,
  *     java.util.Map, org.openmrs.calculation.patient.PatientCalculationContext)
  * @param cohort
  * @param parameterValues
  * @param context
  * @return true for deceased patients
  * @return False for non deceased patients
  */
 @Override
 public CalculationResultMap evaluate(
     Collection<Integer> cohort,
     Map<String, Object> parameterValues,
     PatientCalculationContext context) {
   Program hivProgram = MetadataUtils.existing(Program.class, HivMetadata._Program.HIV);
   Set<Integer> inHivProgram = Filters.inProgram(hivProgram, cohort, context);
   Set<Integer> alive = Filters.alive(cohort, context);
   CalculationResultMap ret = new CalculationResultMap();
   for (Integer ptId : cohort) {
     boolean dead = false;
     if (inHivProgram.contains(ptId) && !(alive.contains(ptId))) {
       dead = true;
     }
     ret.put(ptId, new SimpleResult(dead, this, context));
   }
   return ret;
 }
  /**
   * @see
   *     org.openmrs.module.kenyaemr.calculation.cd4.NeedsCD4Calculation#evaluate(java.util.Collection,
   *     java.util.Map, org.openmrs.calculation.patient.PatientCalculationContext)
   * @verifies calculate last CD4 percentage for all patients
   */
  @Test
  public void evaluate_shouldCalculateLastCD4() throws Exception {

    PatientService ps = Context.getPatientService();
    Concept cd4Percent =
        Context.getConceptService().getConceptByUuid(MetadataConstants.CD4_PERCENT_CONCEPT_UUID);

    // Give patient #6 some CD4 obs
    TestUtils.saveObs(ps.getPatient(6), cd4Percent, 20d, TestUtils.date(2012, 12, 1));
    TestUtils.saveObs(ps.getPatient(6), cd4Percent, 30d, TestUtils.date(2010, 11, 1));

    Context.flushSession();

    List<Integer> ptIds = Arrays.asList(6, 999);
    CalculationResultMap resultMap =
        Context.getService(PatientCalculationService.class)
            .evaluate(ptIds, new LastCD4PercentageCalculation());
    Assert.assertEquals(new Double(20d), ((Obs) resultMap.get(6).getValue()).getValueNumeric());
    Assert.assertNull(resultMap.get(999)); // has no recorded CD4 percent
  }
  /**
   * @see DecliningCd4Calculation#evaluate(java.util.Collection, java.util.Map,
   *     org.openmrs.calculation.patient.PatientCalculationContext)
   * @verifies determine whether patients have a decline in CD4
   */
  @Test
  public void evaluate_shouldDetermineWhetherPatientsHasDeclinedCD4() throws Exception {

    // Get HIV Program
    Program hivProgram = Metadata.getProgram(Metadata.HIV_PROGRAM);

    // Enroll patients #6, #7 and #8 in the HIV Program
    PatientService ps = Context.getPatientService();
    for (int i = 6; i <= 8; ++i) {
      TestUtils.enrollInProgram(ps.getPatient(i), hivProgram, new Date());
    }

    // Give patients #7 and #8 a CD4 count 180 days ago
    Concept cd4 = Dictionary.getConcept(Dictionary.CD4_COUNT);
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.DATE, -180);
    TestUtils.saveObs(ps.getPatient(7), cd4, 123d, calendar.getTime());
    TestUtils.saveObs(ps.getPatient(8), cd4, 123d, calendar.getTime());

    // Give patient #7 a lower CD4 count today
    TestUtils.saveObs(ps.getPatient(7), cd4, 120d, new Date());

    // Give patient #8 a higher CD4 count today
    TestUtils.saveObs(ps.getPatient(8), cd4, 126d, new Date());

    Context.flushSession();

    List<Integer> ptIds = Arrays.asList(6, 7, 8, 999);

    CalculationResultMap resultMap =
        Context.getService(PatientCalculationService.class)
            .evaluate(ptIds, new DecliningCd4Calculation());
    Assert.assertFalse(
        (Boolean) resultMap.get(6).getValue()); // in Hiv program but without cd4 i.e needs cd4
    Assert.assertTrue((Boolean) resultMap.get(7).getValue()); // has decline in CD4
    Assert.assertFalse((Boolean) resultMap.get(8).getValue()); // has increase in CD4
    Assert.assertFalse((Boolean) resultMap.get(999).getValue()); // not in HIV Program
  }
 /**
  * Extracts patients from a calculation result map with date results in the given range
  *
  * @param results the calculation result map
  * @param minDateInclusive the minimum date (inclusive)
  * @param maxDateInclusive the maximum date (inclusive)
  * @return the extracted patient ids
  */
 protected static Set<Integer> datesWithinRange(
     CalculationResultMap results, Date minDateInclusive, Date maxDateInclusive) {
   Set<Integer> ret = new HashSet<Integer>();
   for (Map.Entry<Integer, CalculationResult> e : results.entrySet()) {
     Date result = null;
     try {
       result = e.getValue().asType(Date.class);
     } catch (Exception ex) {
       // pass
     }
     if (result != null) {
       if (OpenmrsUtil.compareWithNullAsEarliest(result, minDateInclusive) >= 0
           && OpenmrsUtil.compareWithNullAsLatest(result, maxDateInclusive) <= 0) {
         ret.add(e.getKey());
       }
     }
   }
   return ret;
 }
  /**
   * @see EligibleForArtTriggerCalculation#evaluate(java.util.Collection, java.util.Map,
   *     org.openmrs.calculation.patient.PatientCalculationContext)
   * @verifies calculate the obs which triggered a patient to become eligible for ART
   * @verifies return null for patients who have never been eligible for ART
   */
  @Test
  public void evaluate_shouldCalculateEligibilityTrigger() throws Exception {

    PatientService ps = Context.getPatientService();

    // Confirm patient #6 HIV+ when they're 1 year old and give them very low CD4 soon after
    TestUtils.saveObs(
        ps.getPatient(6),
        Dictionary.getConcept(Dictionary.DATE_OF_HIV_DIAGNOSIS),
        TestUtils.date(2008, 05, 27),
        TestUtils.date(2010, 1, 1));
    TestUtils.saveObs(
        ps.getPatient(6),
        Dictionary.getConcept(Dictionary.CD4_COUNT),
        300.0,
        TestUtils.date(2009, 1, 1));

    // Give patient #7 low CD4 when they're 3 years old and very low CD4 after
    TestUtils.saveObs(
        ps.getPatient(7),
        Dictionary.getConcept(Dictionary.CD4_COUNT),
        900.0,
        TestUtils.date(1979, 8, 25));
    TestUtils.saveObs(
        ps.getPatient(7),
        Dictionary.getConcept(Dictionary.CD4_COUNT),
        300.0,
        TestUtils.date(2009, 1, 1));

    // Give patient #8 WHO stage of 3
    TestUtils.saveObs(
        ps.getPatient(8),
        Dictionary.getConcept(Dictionary.CURRENT_WHO_STAGE),
        Dictionary.getConcept(Dictionary.WHO_STAGE_3_PEDS),
        TestUtils.date(2009, 1, 1));

    Context.flushSession();

    List<Integer> cohort = Arrays.asList(6, 7, 8, 999);

    CalculationResultMap resultMap =
        new EligibleForArtTriggerCalculation()
            .evaluate(
                cohort,
                null,
                Context.getService(PatientCalculationService.class).createCalculationContext());

    Obs patient6Trigger = (Obs) resultMap.get(6).getValue(); // Eligible through HIV confirmation
    Assert.assertEquals(Dictionary.DATE_OF_HIV_DIAGNOSIS, patient6Trigger.getConcept().getUuid());
    Assert.assertEquals(TestUtils.date(2008, 05, 27), patient6Trigger.getValueDate());

    Obs patient7Trigger = (Obs) resultMap.get(7).getValue(); // Eligible through CD4 count
    Assert.assertEquals(Dictionary.CD4_COUNT, patient7Trigger.getConcept().getUuid());
    Assert.assertEquals(TestUtils.date(1979, 8, 25), patient7Trigger.getObsDatetime());

    Obs patient8Trigger = (Obs) resultMap.get(8).getValue(); // Eligible through WHO stage
    Assert.assertEquals(Dictionary.CURRENT_WHO_STAGE, patient8Trigger.getConcept().getUuid());
    Assert.assertEquals(TestUtils.date(2009, 1, 1), patient8Trigger.getObsDatetime());

    Assert.assertNull(resultMap.get(999)); // Was never eligible for ART
  }
コード例 #16
0
  @Override
  public CalculationResultMap evaluate(
      Collection<Integer> cohort,
      Map<String, Object> parameterValues,
      PatientCalculationContext context) {
    Program hivProgram = MetadataUtils.existing(Program.class, HivMetadata._Program.HIV);

    Set<Integer> alive = Filters.alive(cohort, context);
    Set<Integer> inHivProgram = Filters.inProgram(hivProgram, alive, context);

    Set<Integer> aliveAndFemale = Filters.female(Filters.alive(cohort, context), context);

    CalculationResultMap ret = new CalculationResultMap();

    // need to exclude those on ART already
    Set<Integer> onArt =
        CalculationUtils.patientsThatPass(calculate(new OnArtCalculation(), cohort, context));
    // find the observation for viral load recorded
    CalculationResultMap viralLoad =
        Calculations.lastObs(Dictionary.getConcept(Dictionary.HIV_VIRAL_LOAD), cohort, context);
    // get a list of all the viral load
    CalculationResultMap viralLoadList =
        Calculations.allObs(Dictionary.getConcept(Dictionary.HIV_VIRAL_LOAD), cohort, context);
    // check for non detectables
    CalculationResultMap ldlViralLoad =
        Calculations.allObs(
            Dictionary.getConcept(Dictionary.HIV_VIRAL_LOAD_QUALITATIVE), cohort, context);

    // check for test orders
    CalculationResultMap testOrders =
        Calculations.allObs(Dictionary.getConcept(Dictionary.TESTS_ORDERED), cohort, context);

    // check for last ldl
    CalculationResultMap ldlLast =
        Calculations.lastObs(
            Dictionary.getConcept(Dictionary.HIV_VIRAL_LOAD_QUALITATIVE), cohort, context);

    // find for prgnant females

    CalculationResultMap pregStatusObss =
        Calculations.lastObs(
            Dictionary.getConcept(Dictionary.PREGNANCY_STATUS), aliveAndFemale, context);

    // get the initial art start date
    CalculationResultMap artStartDate =
        calculate(new InitialArtStartDateCalculation(), cohort, context);

    for (Integer ptId : cohort) {
      boolean needsViralLoadTest = false;
      Obs viralLoadObs = EmrCalculationUtils.obsResultForPatient(viralLoad, ptId);
      Date dateInitiated = EmrCalculationUtils.datetimeResultForPatient(artStartDate, ptId);
      ListResult listResult = (ListResult) viralLoadList.get(ptId);
      ListResult testOrdersList = (ListResult) testOrders.get(ptId);
      List<Obs> testObsList = CalculationUtils.extractResultValues(testOrdersList);
      List<Obs> listObsViralLoads = CalculationUtils.extractResultValues(listResult);
      ListResult ldlList = (ListResult) ldlViralLoad.get(ptId);
      List<List> listLdl = CalculationUtils.extractResultValues(ldlList);
      Obs lastLdlObs = EmrCalculationUtils.obsResultForPatient(ldlLast, ptId);
      // find pregnancy obs
      Obs pregnantEdd = EmrCalculationUtils.obsResultForPatient(pregStatusObss, ptId);

      // Find latest viral load test order
      Obs lastVlTestOrder = getLatestVlOrder(testObsList);

      if (inHivProgram.contains(ptId) && onArt.contains(ptId)) {
        if (listObsViralLoads.size() == 0
            && listLdl.size() == 0
            && dateInitiated != null
            && (daysSince(dateInitiated, context) >= 180)) {
          needsViralLoadTest = true;
        }
        // need to check here if patient has had any viral load
        /*if(dateInitiated != null && (daysSince(dateInitiated, context) >= 360)) {
            needsViralLoadTest = true;
        }*/

        // those continuing should receive one VL every year
        // pick the date of the last viral load numeric values
        if (viralLoadObs != null && (daysSince(viralLoadObs.getObsDatetime(), context) >= 360)) {
          needsViralLoadTest = true;
        }
        // pick the date of the ldl
        if (lastLdlObs != null && (daysSince(lastLdlObs.getObsDatetime(), context) >= 360)) {
          needsViralLoadTest = true;
        }

        // if vl more than
        if (viralLoadObs != null
            && viralLoadObs.getValueNumeric() > 1000
            && (daysSince(viralLoadObs.getObsDatetime(), context) > 90)) {
          needsViralLoadTest = true;

          if (lastLdlObs != null && (daysSince(lastLdlObs.getObsDatetime(), context) < 360)) {
            needsViralLoadTest = false;
          }
        }

        // check for pregnancy
        if (pregnantEdd != null
            && pregnantEdd.getValueCoded().equals(Dictionary.getConcept(Dictionary.YES))
            && dateInitiated != null) {
          Date whenVLWillBeDue =
              DateUtil.adjustDate(
                  DateUtil.adjustDate(dateInitiated, 6, DurationUnit.MONTHS),
                  -1,
                  DurationUnit.DAYS);
          // if last vl is 6 months older then the patient is due for vl
          if (viralLoadObs == null && lastLdlObs == null) {
            needsViralLoadTest = true;
          }
          if (viralLoadObs == null
              && lastLdlObs == null
              && (context.getNow().after(whenVLWillBeDue))) {
            needsViralLoadTest = true;
          }
          if (viralLoadObs != null
              && viralLoadObs.getValueNumeric() > 1000
              && (monthsBetween(viralLoadObs.getObsDatetime(), context.getNow()) >= 3)) {
            needsViralLoadTest = true;
            if (lastLdlObs != null && (daysSince(lastLdlObs.getObsDatetime(), context) < 360)) {
              needsViralLoadTest = false;
            }
          }
          if (viralLoadObs != null && daysSince(viralLoadObs.getObsDatetime(), context) >= 180) {
            needsViralLoadTest = true;
          }
          if (lastLdlObs != null && daysSince(lastLdlObs.getObsDatetime(), context) >= 180) {
            needsViralLoadTest = true;
          }
        }

        // check if has vl test order within 6 months
        if (lastVlTestOrder != null
            && daysSince(lastVlTestOrder.getObsDatetime(), context) >= 180) {
          needsViralLoadTest = true;
        }

        if (lastVlTestOrder != null && daysSince(lastVlTestOrder.getObsDatetime(), context) < 180) {
          needsViralLoadTest = false;
        }
      }

      ret.put(ptId, new BooleanResult(needsViralLoadTest, this));
    }
    return ret;
  }