/**
   * @see RegimenManager#findDefinitions(String, org.openmrs.module.kenyaemr.regimen.RegimenOrder,
   *     boolean)
   */
  @Test
  public void findDefinitions_shouldFindDefinitionsForRegimen() {
    // Create regimen that matches the regimen2 definition exactly
    DrugOrder lamivudine = new DrugOrder();
    lamivudine.setConcept(Context.getConceptService().getConcept(78643));
    lamivudine.setDose(150d);
    lamivudine.setUnits("mg");
    lamivudine.setFrequency("BD");
    DrugOrder stavudine = new DrugOrder();
    stavudine.setConcept(Context.getConceptService().getConcept(84309));
    stavudine.setDose(30d);
    stavudine.setUnits("mg");
    stavudine.setFrequency("OD");
    RegimenOrder regimen =
        new RegimenOrder(new HashSet<DrugOrder>(Arrays.asList(lamivudine, stavudine)));

    // Test exact match
    List<RegimenDefinition> defsExact = regimenManager.findDefinitions("category1", regimen, true);
    Assert.assertEquals(1, defsExact.size());
    Assert.assertEquals("regimen2", defsExact.get(0).getName());

    // Test non-exact match
    List<RegimenDefinition> defsNonExact =
        regimenManager.findDefinitions("category1", regimen, false);
    Assert.assertEquals(2, defsNonExact.size());
    Assert.assertEquals("regimen2", defsNonExact.get(0).getName());
    Assert.assertEquals("regimen3", defsNonExact.get(1).getName());
  }
 /**
  * @verifies fail validation if frequency is null for SIMPLE dosingType
  * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
  */
 @Test
 public void validate_shouldFailValidationIfFrequencyIsNullForSIMPLEDosingType() throws Exception {
   DrugOrder order = new DrugOrder();
   order.setDosingType(DrugOrder.DosingType.SIMPLE);
   order.setFrequency(null);
   Errors errors = new BindException(order, "order");
   new DrugOrderValidator().validate(order, errors);
   Assert.assertTrue(errors.hasFieldErrors("frequency"));
 }
 @Override
 public Date getAutoExpireDate(DrugOrder drugOrder) {
   return DrugOrderUtil.calculateAutoExpireDate(
       drugOrder.getDuration(),
       drugOrder.getDurationUnits(),
       drugOrder.getNumRefills(),
       drugOrder.getEffectiveStartDate(),
       drugOrder.getFrequency());
 }
 /**
  * @verifies fail validation if doseUnits is null when dose is present
  * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
  */
 @Test
 public void validate_shouldFailValidationIfDoseUnitsIsNullWhenDoseIsPresent() throws Exception {
   DrugOrder order = new DrugOrder();
   order.setDosingType(DrugOrder.DosingType.FREE_TEXT);
   order.setDose(20.0);
   order.setDoseUnits(null);
   Errors errors = new BindException(order, "order");
   new DrugOrderValidator().validate(order, errors);
   Assert.assertTrue(errors.hasFieldErrors("doseUnits"));
 }
 /**
  * @verifies fail validation if dosingInstructions is null for FREE_TEXT dosingType
  * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
  */
 @Test
 public void validate_shouldFailValidationIfDosingInstructionsIsNullForFREE_TEXTDosingType()
     throws Exception {
   DrugOrder order = new DrugOrder();
   order.setDosingType(DrugOrder.DosingType.FREE_TEXT);
   order.setDosingInstructions(null);
   Errors errors = new BindException(order, "order");
   new DrugOrderValidator().validate(order, errors);
   Assert.assertTrue(errors.hasFieldErrors("dosingInstructions"));
 }
 @Test
 public void getAutoExpireDate_shouldInferAutoExpireDateForAKnownSNOMEDCTDurationUnit()
     throws Exception {
   DrugOrder drugOrder = new DrugOrder();
   drugOrder.setDateActivated(createDateTime("2014-07-01 10:00:00"));
   drugOrder.setDuration(30);
   drugOrder.setDurationUnits(createUnits(Duration.SNOMED_CT_SECONDS_CODE));
   Date autoExpireDate = new SimpleDosingInstructions().getAutoExpireDate(drugOrder);
   assertEquals(createDateTime("2014-07-01 10:00:29"), autoExpireDate);
 }
 private DrugOrder createValidDrugOrder() {
   DrugOrder drugOrder = new DrugOrder();
   drugOrder.setDose(10.0);
   drugOrder.setDoseUnits(createConceptWithName("ml"));
   drugOrder.setRoute(createConceptWithName("IV"));
   OrderFrequency frequency = new OrderFrequency();
   frequency.setConcept(createConceptWithName("Twice a day"));
   drugOrder.setFrequency(frequency);
   return drugOrder;
 }
  @Test
  @Verifies(
      value = "should return encounter with all child objects voided according to schema",
      method = "voidEncounterByHtmlFormSchema")
  public void testVoidEncounterByHtmlFormSchema_shouldHandleDrugOrderCorrectly() throws Exception {
    executeDataSet(
        XML_DATASET_PATH + new TestUtil().getTestDatasetFilename(XML_REGRESSION_TEST_DATASET));
    Encounter e = new Encounter();
    e.setPatient(Context.getPatientService().getPatient(2));
    Date date = Context.getDateFormat().parse("01/02/2003");
    e.setDateCreated(new Date());
    e.setEncounterDatetime(date);
    e.setLocation(Context.getLocationService().getLocation(2));
    e.setProvider(Context.getPersonService().getPerson(502));
    TestUtil.addObs(e, 1, 5000, date); // a matching obs

    DrugOrder dor = new DrugOrder();
    dor.setVoided(false);
    dor.setConcept(Context.getConceptService().getConcept(792));
    dor.setCreator(Context.getUserService().getUser(1));
    dor.setDateCreated(new Date());
    dor.setDiscontinued(false);
    dor.setDrug(Context.getConceptService().getDrug(2));
    dor.setOrderType(Context.getOrderService().getOrderType(1));
    dor.setPatient(Context.getPatientService().getPatient(2));
    dor.setStartDate(new Date());
    e.addOrder(dor);

    Context.getEncounterService().saveEncounter(e);

    Form form = new Form();
    HtmlForm htmlform = new HtmlForm();
    htmlform.setForm(form);
    form.setEncounterType(new EncounterType());
    htmlform.setDateChanged(new Date());
    htmlform.setXmlData(
        new TestUtil()
            .loadXmlFromFile(
                XML_DATASET_PATH + "returnSectionsAndConceptsInSectionsTestFormWithGroups.xml"));

    HtmlFormEntryUtil.voidEncounterByHtmlFormSchema(e, htmlform, "test void reason");

    // this is going to test out the voided state of the obs in the encounter after processing:
    // order was matched, so order was voided, and because that's the only thing in the encounter,
    // encounter was voided too.
    Assert.assertTrue(e.isVoided());
    Assert.assertTrue(e.getVoidReason().equals("test void reason"));
    for (Order o : e.getOrders()) {
      Assert.assertTrue(o.isVoided());
      Assert.assertTrue(o.getVoidReason().equals("test void reason"));
    }
    for (Obs o : e.getAllObs(true)) {
      Assert.assertTrue(o.getVoidReason().equals("test void reason"));
    }
  }
 @Override
 public DosingInstructions getDosingInstructions(DrugOrder order) {
   if (!order.getDosingType().equals(this.getClass())) {
     throw new APIException(
         "Dosing type of drug order is mismatched. Expected:"
             + this.getClass()
             + " but received:"
             + order.getDosingType());
   }
   return new FlexibleDosingInstructions();
 }
  @Test
  public void validate_shouldPassValidationIfAutoExpireDateAndDurationUnitsAreNotSet()
      throws Exception {
    DrugOrder drugOrder = createValidDrugOrder();
    drugOrder.setDurationUnits(null);
    drugOrder.setAutoExpireDate(null);
    Errors errors = new BindException(drugOrder, "drugOrder");

    new SimpleDosingInstructions().validate(drugOrder, errors);

    Assert.assertFalse(errors.hasErrors());
  }
  @Test
  public void getAutoExpireDate_shouldNotInferAutoExpireDateWhenDurationUnitsDoesNotExist()
      throws Exception {
    DrugOrder drugOrder = new DrugOrder();
    drugOrder.setDateActivated(createDateTime("2014-07-01 10:00:00"));
    drugOrder.setDuration(1);
    drugOrder.setDurationUnits(null);

    Date autoExpireDate = new SimpleDosingInstructions().getAutoExpireDate(drugOrder);

    assertEquals(null, autoExpireDate);
  }
  @Test
  @Verifies(
      value = "should return encounter with all child objects voided according to schema",
      method = "voidEncounterByHtmlFormSchema")
  public void testVoidEncounterByHtmlFormSchema_shouldHandleDrugOrderAndObsCorrectly()
      throws Exception {
    executeDataSet(
        XML_DATASET_PATH + new TestUtil().getTestDatasetFilename(XML_REGRESSION_TEST_DATASET));
    Encounter e = new Encounter();
    e.setPatient(Context.getPatientService().getPatient(2));
    Date date = Context.getDateFormat().parse("01/02/2003");
    e.setDateCreated(new Date());
    e.setEncounterDatetime(date);
    e.setLocation(Context.getLocationService().getLocation(2));
    e.setProvider(Context.getPersonService().getPerson(502));
    TestUtil.addObs(e, 3, 5000, date); // adding an un-matched Obs

    DrugOrder dor = new DrugOrder();
    dor.setVoided(false);
    dor.setConcept(Context.getConceptService().getConcept(792));
    dor.setCreator(Context.getUserService().getUser(1));
    dor.setDateCreated(new Date());
    dor.setDiscontinued(false);
    dor.setDrug(Context.getConceptService().getDrug(2));
    dor.setOrderType(Context.getOrderService().getOrderType(1));
    dor.setPatient(Context.getPatientService().getPatient(2));
    dor.setStartDate(new Date());
    e.addOrder(dor);

    Context.getEncounterService().saveEncounter(e);

    Form form = new Form();
    HtmlForm htmlform = new HtmlForm();
    htmlform.setForm(form);
    form.setEncounterType(new EncounterType());
    htmlform.setDateChanged(new Date());
    htmlform.setXmlData(
        new TestUtil()
            .loadXmlFromFile(
                XML_DATASET_PATH + "returnSectionsAndConceptsInSectionsTestFormWithGroups.xml"));

    HtmlFormEntryUtil.voidEncounterByHtmlFormSchema(e, htmlform, null);

    // order was matched, obs was not, so order should be voided, obs not, encounter not.
    Assert.assertTrue(!e.isVoided());
    for (Order o : e.getOrders()) {
      Assert.assertTrue(o.isVoided());
    }
    for (Obs o : e.getObs()) {
      Assert.assertTrue(!o.isVoided());
    }
  }
  /** @see {@link DrugOrderValidator#validate(Object,Errors)} */
  @Test
  @Verifies(
      value = "should not fail validation if drug is null",
      method = "validate(Object,Errors)")
  public void validate_shouldNotFailValidationIfDrugIsNull() throws Exception {
    DrugOrder order = new DrugOrder();
    order.setDrug(null);

    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);

    Assert.assertFalse(errors.hasFieldErrors("drug"));
  }
  /**
   * @verifies reject a duration unit with a mapping of an invalid type
   * @see SimpleDosingInstructions#validate(DrugOrder, org.springframework.validation.Errors)
   */
  @Test
  public void validate_shouldRejectADurationUnitWithAMappingOfAnInvalidType() throws Exception {
    DrugOrder drugOrder = createValidDrugOrder();
    drugOrder.setDuration(30);
    Concept durationUnitWithInvalidMapType =
        createUnits("SCT", Duration.SNOMED_CT_DAYS_CODE, "Some-uuid");
    drugOrder.setDurationUnits(durationUnitWithInvalidMapType);
    Errors errors = new BindException(drugOrder, "drugOrder");

    new SimpleDosingInstructions().validate(drugOrder, errors);

    assertEquals(true, errors.hasErrors());
  }
  @Test
  public void
      getAutoExpireDate_shouldNotInferAutoExpireDateWhenConceptMappingOfSourceSNOMEDCTDurationDoesNotExist()
          throws Exception {
    DrugOrder drugOrder = new DrugOrder();
    drugOrder.setDateActivated(createDateTime("2014-07-01 10:00:00"));
    drugOrder.setDuration(30);
    drugOrder.setDurationUnits(createUnits("Other.Source", Duration.SNOMED_CT_HOURS_CODE, null));

    Date autoExpireDate = new SimpleDosingInstructions().getAutoExpireDate(drugOrder);

    assertEquals(null, autoExpireDate);
  }
  @Test
  public void getAutoExpireDate_shouldNotInferAutoExpireDateWhenDrugOrderHasOneOrMoreRefill()
      throws Exception {
    DrugOrder drugOrder = new DrugOrder();
    drugOrder.setDateActivated(createDateTime("2014-07-01 10:00:00"));
    drugOrder.setDuration(30);
    drugOrder.setDurationUnits(createUnits(Duration.SNOMED_CT_SECONDS_CODE));
    drugOrder.setNumRefills(1);

    Date autoExpireDate = new SimpleDosingInstructions().getAutoExpireDate(drugOrder);

    assertEquals(null, autoExpireDate);
  }
  /** @see {@link DrugOrderValidator#validate(Object,Errors)} */
  @Test
  @Verifies(
      value = "should fail validation if dosingType is null",
      method = "validate(Object,Errors)")
  public void validate_shouldFailValidationIfDosingTypeIsNull() throws Exception {
    DrugOrder order = new DrugOrder();
    order.setDosingType(null);
    order.setDrug(Context.getConceptService().getDrug(3));

    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);

    Assert.assertTrue(errors.hasFieldErrors("dosingType"));
  }
  @Test
  public void
      validate_shouldPassValidationIfAutoExpireDateIsSetAndDurationUnitsIsNotMappedToSNOMEDCTDuration()
          throws Exception {
    DrugOrder drugOrder = createValidDrugOrder();
    drugOrder.setDuration(30);
    Concept unMappedDurationUnits = new Concept();
    drugOrder.setDurationUnits(unMappedDurationUnits);
    drugOrder.setAutoExpireDate(createDateTime("2014-07-01 10:00:00"));
    Errors errors = new BindException(drugOrder, "drugOrder");

    new SimpleDosingInstructions().validate(drugOrder, errors);

    Assert.assertFalse(errors.hasErrors());
  }
  @Test
  public void
      validate_shouldFailValidationIfAutoExpireDateIsNotSetAndDurationUnitsIsNotMappedToSNOMEDCTDuration()
          throws Exception {
    DrugOrder drugOrder = createValidDrugOrder();
    drugOrder.setDuration(30);
    Concept unMappedDurationUnits = new Concept();
    drugOrder.setDurationUnits(unMappedDurationUnits);
    drugOrder.setAutoExpireDate(null);
    Errors errors = new BindException(drugOrder, "drugOrder");

    new SimpleDosingInstructions().validate(drugOrder, errors);

    Assert.assertTrue(errors.hasFieldErrors("durationUnits"));
    Assert.assertEquals(
        "DrugOrder.error.durationUnitsNotMappedToSnomedCtDurationCode",
        errors.getFieldError("durationUnits").getCode());
  }
  /** @see {@link DrugOrderValidator#validate(Object,Errors)} */
  @Test
  @Verifies(
      value = "should fail validation if drug concept is different from order concept",
      method = "validate(Object,Errors)")
  public void validate_shouldFailValidationIfDrugConceptIsDifferentFromOrderConcept()
      throws Exception {
    DrugOrder order = new DrugOrder();
    Drug drug = Context.getConceptService().getDrug(3);
    Concept concept = Context.getConceptService().getConcept(792);
    order.setDrug(drug);
    order.setConcept(concept); // the actual concept which matches with drug is "88"
    Assert.assertNotEquals(drug.getConcept(), concept);

    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);

    Assert.assertTrue(errors.hasFieldErrors("concept"));
    Assert.assertTrue(errors.hasFieldErrors("drug"));
  }
  public PatientDataResult evaluate(RowPerPatientData patientData, EvaluationContext context) {

    DateResult par = new DateResult(patientData, context);
    DateOfFirstDrugOrderStartedRestrictedByConceptSet pd =
        (DateOfFirstDrugOrderStartedRestrictedByConceptSet) patientData;

    par.setFormat(pd.getDateFormat());

    List<DrugOrder> orders = Context.getOrderService().getDrugOrdersByPatient(pd.getPatient());

    if (orders != null) {
      if (pd.getDrugConceptSetConcept() != null) {
        List<Concept> drugConcepts =
            Context.getConceptService().getConceptsByConceptSet(pd.getDrugConceptSetConcept());
        if (drugConcepts != null) {
          DrugOrder startDrugOrder = null;
          for (DrugOrder order : orders) {
            Concept drug = null;
            try {
              drug = order.getDrug().getConcept();
            } catch (Exception e) {
              log.error("Unable to retrieve a drug from the drug order: " + e.getMessage());
            }
            if (drug != null) {
              if (drugConcepts.contains(drug)) {
                if (order.getStartDate() != null
                    && (pd.getStartDate() == null
                        || OpenmrsUtil.compare(order.getStartDate(), pd.getStartDate()) >= 0)
                    && (pd.getEndDate() == null
                        || OpenmrsUtil.compare(order.getStartDate(), pd.getEndDate()) <= 0)) {
                  if (startDrugOrder == null
                      || order.getStartDate().before(startDrugOrder.getStartDate())) {
                    startDrugOrder = order;
                  }
                }
              }
            }
          }
          if (startDrugOrder != null) {
            par.setValue(startDrugOrder.getStartDate());
          }
        }
      }
    }

    return par;
  }
  /**
   * @verifies fail if route is not a valid concept
   * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
   */
  @Test
  public void validate_shouldFailIfRouteIsNotAValidConcept() throws Exception {
    Concept concept = Context.getConceptService().getConcept(3);
    assertThat(concept, not(isIn(Context.getOrderService().getDrugRoutes())));

    DrugOrder order = new DrugOrder();
    order.setDosingType(DrugOrder.DosingType.FREE_TEXT);
    order.setDuration(5.0);
    order.setDurationUnits(concept);
    order.setDose(1.0);
    order.setDoseUnits(concept);
    order.setQuantity(30.0);
    order.setQuantityUnits(concept);
    order.setRoute(concept);

    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    Assert.assertTrue(errors.hasFieldErrors("route"));
    Assert.assertEquals(
        "DrugOrder.error.routeNotAmongAllowedConcepts", errors.getFieldError("route").getCode());
  }
  /**
   * @see DrugOrderValidator#validate(Object,Errors)
   * @verifies fail validation if doseUnits is not a dose unit concept
   */
  @Test
  public void validate_shouldFailValidationIfDoseUnitsIsNotADoseUnitConcept() throws Exception {
    Concept concept = Context.getConceptService().getConcept(3);
    assertThat(concept, not(isIn(Context.getOrderService().getDrugDosingUnits())));

    DrugOrder order = new DrugOrder();
    order.setDosingType(DrugOrder.DosingType.FREE_TEXT);
    order.setDuration(5.0);
    order.setDurationUnits(concept);
    order.setDose(1.0);
    order.setDoseUnits(concept);
    order.setQuantity(30.0);
    order.setQuantityUnits(concept);

    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    Assert.assertTrue(errors.hasFieldErrors("doseUnits"));
  }
 @Test
 public void getAutoExpireDate_shouldInferAutoExpireDateForScheduledDrugOrder() throws Exception {
   DrugOrder drugOrder = new DrugOrder();
   drugOrder.setDateActivated(createDateTime("2014-07-01 00:00:00"));
   drugOrder.setScheduledDate(createDateTime("2014-07-05 00:00:00"));
   drugOrder.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);
   drugOrder.setDuration(10);
   drugOrder.setDurationUnits(createUnits(Duration.SNOMED_CT_DAYS_CODE));
   Date autoExpireDate = new SimpleDosingInstructions().getAutoExpireDate(drugOrder);
   assertEquals(createDateTime("2014-07-14 23:59:59"), autoExpireDate);
 }
  /**
   * @verifies fail validation if numberOfRefills is null for outpatient careSetting
   * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
   */
  @Test
  public void validate_shouldFailValidationIfNumberOfRefillsIsNullForOutpatientCareSetting()
      throws Exception {
    DrugOrder OutpatientOrder = new DrugOrder();
    OutpatientOrder.setCareSetting(Context.getOrderService().getCareSetting(1));
    OutpatientOrder.setNumRefills(null);
    Errors OutpatientOrderErrors = new BindException(OutpatientOrder, "order");
    new DrugOrderValidator().validate(OutpatientOrder, OutpatientOrderErrors);
    Assert.assertTrue(OutpatientOrderErrors.hasFieldErrors("numRefills"));

    DrugOrder inPatientOrder = new DrugOrder();
    inPatientOrder.setCareSetting(Context.getOrderService().getCareSetting(2));
    inPatientOrder.setNumRefills(null);
    Errors InpatientOrderErrors = new BindException(inPatientOrder, "order");
    new DrugOrderValidator().validate(inPatientOrder, InpatientOrderErrors);
    Assert.assertFalse(InpatientOrderErrors.hasFieldErrors("numRefills"));
  }
  @Override
  public EncounterTransaction.DrugOrder mapDrugOrder(DrugOrder openMRSDrugOrder) {
    EncounterTransaction.DrugOrder drugOrder = new EncounterTransaction.DrugOrder();
    drugOrder.setUuid(openMRSDrugOrder.getUuid());
    if (openMRSDrugOrder.getCareSetting() != null) {
      drugOrder.setCareSetting(
          CareSettingType.valueOf(
              openMRSDrugOrder.getCareSetting().getCareSettingType().toString()));
    }
    drugOrder.setAction(openMRSDrugOrder.getAction().name());
    drugOrder.setOrderType(openMRSDrugOrder.getOrderType().getName());

    org.openmrs.Order previousOrder = openMRSDrugOrder.getPreviousOrder();
    if (previousOrder != null && StringUtils.isNotBlank(previousOrder.getUuid())) {
      drugOrder.setPreviousOrderUuid(previousOrder.getUuid());
    }

    EncounterTransaction.Drug encounterTransactionDrug =
        new DrugMapper1_11().map(openMRSDrugOrder.getDrug());
    drugOrder.setDrug(encounterTransactionDrug);

    drugOrder.setDosingInstructionType(openMRSDrugOrder.getDosingType().getName());
    drugOrder.setDuration(openMRSDrugOrder.getDuration());
    drugOrder.setDurationUnits(getConceptName(openMRSDrugOrder.getDurationUnits()));

    drugOrder.setScheduledDate(openMRSDrugOrder.getScheduledDate());
    drugOrder.setDateActivated(openMRSDrugOrder.getDateActivated());
    drugOrder.setEffectiveStartDate(openMRSDrugOrder.getEffectiveStartDate());
    drugOrder.setAutoExpireDate(openMRSDrugOrder.getAutoExpireDate());
    drugOrder.setEffectiveStopDate(openMRSDrugOrder.getEffectiveStopDate());

    drugOrder.setDateStopped(openMRSDrugOrder.getDateStopped());

    EncounterTransaction.DosingInstructions dosingInstructions =
        new EncounterTransaction.DosingInstructions();
    dosingInstructions.setDose(openMRSDrugOrder.getDose());
    dosingInstructions.setDoseUnits(getConceptName(openMRSDrugOrder.getDoseUnits()));
    dosingInstructions.setRoute(getConceptName(openMRSDrugOrder.getRoute()));
    dosingInstructions.setAsNeeded(openMRSDrugOrder.getAsNeeded());
    if (openMRSDrugOrder.getFrequency() != null) {
      dosingInstructions.setFrequency(openMRSDrugOrder.getFrequency().getName());
    }
    if (openMRSDrugOrder.getQuantity() != null) {
      dosingInstructions.setQuantity(openMRSDrugOrder.getQuantity());
    }
    dosingInstructions.setQuantityUnits(getConceptName(openMRSDrugOrder.getQuantityUnits()));
    dosingInstructions.setAdministrationInstructions(openMRSDrugOrder.getDosingInstructions());
    drugOrder.setDosingInstructions(dosingInstructions);

    drugOrder.setInstructions(openMRSDrugOrder.getInstructions());
    drugOrder.setCommentToFulfiller(openMRSDrugOrder.getCommentToFulfiller());

    drugOrder.setVoided(openMRSDrugOrder.getVoided());
    drugOrder.setVoidReason(openMRSDrugOrder.getVoidReason());
    drugOrder.setOrderNumber(openMRSDrugOrder.getOrderNumber());

    return drugOrder;
  }
  @Test
  public void shouldAddNewDrugOrder() {

    EncounterTransaction.DrugOrder drugOrder =
        new DrugOrderBuilder()
            .withBasicValues(
                "drug-uuid",
                "test-concept-uuid",
                today,
                today,
                3,
                "dosage-instruction-uuid",
                "dosage-frequency-uuid")
            .withNotes("this is notes")
            .build();
    Concept drugConcept = new Concept(3);
    OrderType drugOrderType = new OrderType("Drug Order", "this is a drug order type");

    when(orderService.getAllOrderTypes()).thenReturn(asList(drugOrderType));
    int instructionConceptId = 1;
    when(conceptService.getConceptByUuid("dosage-instruction-uuid"))
        .thenReturn(new Concept(instructionConceptId));
    Integer frequencyConceptId = 2;
    when(conceptService.getConceptByUuid("dosage-frequency-uuid"))
        .thenReturn(new Concept(frequencyConceptId));
    when(conceptService.getConceptByUuid("test-concept-uuid")).thenReturn(drugConcept);
    Drug drug = new Drug();
    drug.setName("test drug");
    when(conceptService.getDrugByUuid("drug-uuid")).thenReturn(drug);

    encounterDrugOrderServiceHelper.update(encounter, asList(drugOrder));

    assertThat(encounter.getOrders().size(), is(1));
    org.openmrs.DrugOrder order = (org.openmrs.DrugOrder) encounter.getOrders().iterator().next();
    assertEquals(drugConcept, order.getConcept());
    assertEquals(drugOrderType, order.getOrderType());
    assertEquals(patient, order.getPatient());
    assertEquals(encounter, order.getEncounter());
    assertEquals("this is notes", order.getInstructions());
    assertEquals("dosage-instruction-uuid", order.getUnits());
    assertEquals("dosage-frequency-uuid", order.getFrequency());
    assertEquals(today, order.getStartDate());
    assertEquals(today, order.getAutoExpireDate());
    assertEquals(drug.getDisplayName(), order.getDrug().getDisplayName());
    assertEquals(Double.valueOf(3), order.getDose());
    assertEquals(false, order.getPrn());
  }
 @Override
 public void setDosingInstructions(DrugOrder order) {
   order.setDosingType(this.getClass());
 }
  public DataSetRow renderRow(
      Patient p,
      PatientIdentifierType patientIdentifierType,
      Location location,
      Date startDate,
      Date endDate) {

    PatientDataHelper pdh = new PatientDataHelper();
    ProgramHelper ph = new ProgramHelper();
    HivMetadata hivMetadata = new HivMetadata();

    DataSetRow row = new DataSetRow();
    pdh.addCol(row, "#", p.getPatientId());
    pdh.addCol(row, "KS ID", pdh.preferredIdentifierAtLocation(p, patientIdentifierType, location));
    pdh.addCol(
        row,
        "ART ID",
        pdh.preferredIdentifierAtLocation(p, lookupPatientIdentifierType("ARV Number"), location));
    pdh.addCol(row, "Birthdate", pdh.getBirthdate(p));
    pdh.addCol(row, "Gender", pdh.getGender(p));
    pdh.addCol(row, "VHW", pdh.vhwName(p, false));
    pdh.addCol(row, "Village", pdh.getVillage(p));

    PatientProgram latestKsProgram =
        ph.getMostRecentProgramEnrollmentAtLocation(
            p, lookupProgram("Kaposis sarcoma program"), location);

    Date latestKsProgramDate = null;
    if (latestKsProgram != null) {
      latestKsProgramDate = latestKsProgram.getDateEnrolled();
      pdh.addCol(row, "KS Program Enrollment Date", pdh.formatYmd(latestKsProgramDate));

      for (PatientState ps : ph.getActiveStatesOnDate(p, latestKsProgramDate)) {
        String programName = ps.getPatientProgram().getProgram().getName();
        pdh.addCol(row, programName + " Status at Enrollment", pdh.formatStateName(ps));
        pdh.addCol(row, programName + " Status Date at Enrollment", pdh.formatStateStartDate(ps));
      }
    }

    Obs mostRecentDxDate = pdh.getLatestObs(p, "DATE OF HIV DIAGNOSIS", null, endDate);
    pdh.addCol(row, "Date HIV Diagnosis", pdh.formatValueDatetime(mostRecentDxDate));

    Program hivProgram = hivMetadata.getHivProgram();
    ProgramWorkflowState onArvState = hivMetadata.getOnArvsState();

    PatientState earliestOnArvsState = ph.getFirstTimeInState(p, hivProgram, onArvState, endDate);
    Date arvStartDate = (earliestOnArvsState == null ? null : earliestOnArvsState.getStartDate());

    if (latestKsProgramDate != null) {
      pdh.addCol(
          row,
          "On ART at KS Enrollment",
          arvStartDate != null && arvStartDate.compareTo(latestKsProgramDate) <= 0);
    }

    Map<String, String> reasonsForStartingArvs = pdh.getReasonStartingArvs(p, endDate);
    for (String reasonKey : reasonsForStartingArvs.keySet()) {
      pdh.addCol(row, "ARV Reason " + reasonKey, reasonsForStartingArvs.get(reasonKey));
    }

    if (arvStartDate != null) {
      pdh.addCol(row, "Start Date for ART", pdh.formatStateStartDate(earliestOnArvsState));
      if (latestKsProgramDate != null) {
        pdh.addCol(
            row,
            "Months on ART at KS Enrollment",
            DateUtil.monthsBetween(arvStartDate, latestKsProgramDate));
      }
    }

    if (latestKsProgramDate != null) {
      Obs artRegimen =
          pdh.getLatestObs(p, "Malawi Antiretroviral drugs received", null, latestKsProgramDate);
      pdh.addCol(row, "ART Regimen Obs at Enrollment", pdh.formatValue(artRegimen));

      Set<Concept> drugOrdersAtEnrollment = pdh.getDrugsTakingOnDate(p, latestKsProgramDate);
      pdh.addCol(
          row, "Drugs Taking at Enrollment", pdh.formatConcepts(drugOrdersAtEnrollment, "+"));

      Obs cd4 = pdh.getLatestObs(p, "CD4 count", null, latestKsProgramDate);
      pdh.addCol(row, "CD4 at enrollment", pdh.formatValue(cd4));
      pdh.addCol(row, "CD4 at enrollment date", pdh.formatObsDatetime(cd4));
    }

    Obs height = pdh.getLatestObs(p, "Height (cm)", null, endDate);
    pdh.addCol(row, "Latest Height", pdh.formatValue(height));
    pdh.addCol(row, "Latest Height Date", pdh.formatObsDatetime(height));

    Obs firstTaxolObs = pdh.getEarliestObs(p, "Paclitaxel (taxol) dose received", null, endDate);
    pdh.addCol(row, "First Taxol Dose Received Date", pdh.formatObsDatetime(firstTaxolObs));

    DrugOrder firstTaxolOrder = pdh.getEarliestDrugOrder(p, "Paclitaxel", endDate);
    pdh.addCol(row, "First Taxol Drug Order Date", pdh.formatOrderStartDate(firstTaxolOrder));

    Date firstTaxolDate = null;
    if (firstTaxolObs != null) {
      firstTaxolDate = firstTaxolObs.getObsDatetime();
    }
    if (firstTaxolOrder != null) {
      if (firstTaxolDate == null || firstTaxolOrder.getStartDate().before(firstTaxolDate)) {
        firstTaxolDate = firstTaxolOrder.getStartDate();
      }
    }
    pdh.addCol(row, "First Taxol Date", pdh.formatYmd(firstTaxolDate));

    if (firstTaxolDate != null) {
      Obs cd4AtTaxol = pdh.getLatestObs(p, "CD4 count", null, firstTaxolDate);
      pdh.addCol(row, "Most recent CD4 at First Taxol", pdh.formatValue(cd4AtTaxol));
      pdh.addCol(row, "Most recent CD4 at First Taxol Date", pdh.formatObsDatetime(cd4AtTaxol));
    }

    for (PatientState ps : ph.getActiveStatesOnDate(p, endDate)) {
      String ed = pdh.formatYmd(endDate);
      String programName = ps.getPatientProgram().getProgram().getName();
      pdh.addCol(row, programName + " Status on " + ed, pdh.formatStateName(ps));
      pdh.addCol(row, programName + " Status Date on " + ed, pdh.formatStateStartDate(ps));
    }

    pdh.addCol(row, "Death Date", pdh.formatYmd(p.getDeathDate()));

    return row;
  }
Beispiel #30
0
  /**
   * This method produces a model containing the following mappings:
   *
   * <pre>
   *     (always)
   *          (java.util.Date) now
   *          (String) size
   *          (Locale) locale
   *          (String) portletUUID // unique for each instance of any portlet
   *          (other parameters)
   *     (if there's currently an authenticated user)
   *          (User) authenticatedUser
   *     (if the request has a patientId attribute)
   *          (Integer) patientId
   *          (Patient) patient
   *          (List<Obs>) patientObs
   *          (List<Encounter>) patientEncounters
   *          (List<DrugOrder>) patientDrugOrders
   *          (List<DrugOrder>) currentDrugOrders
   *          (List<DrugOrder>) completedDrugOrders
   *          (Obs) patientWeight // most recent weight obs
   *          (Obs) patientHeight // most recent height obs
   *          (Double) patientBmi // BMI derived from most recent weight and most recent height
   *          (String) patientBmiAsString // BMI rounded to one decimal place, or "?" if unknown
   *          (Integer) personId
   *          (if the patient has any obs for the concept in the global property 'concept.reasonExitedCare')
   *              (Obs) patientReasonForExit
   *     (if the request has a personId or patientId attribute)
   *          (Person) person
   *          (List<Relationship>) personRelationships
   *          (Map<RelationshipType, List<Relationship>>) personRelationshipsByType
   *     (if the request has an encounterId attribute)
   *          (Integer) encounterId
   *          (Encounter) encounter
   *          (Set<Obs>) encounterObs
   *     (if the request has a userId attribute)
   *          (Integer) userId
   *          (User) user
   *     (if the request has a patientIds attribute, which should be a (String) comma-separated list of patientIds)
   *          (PatientSet) patientSet
   *          (String) patientIds
   *     (if the request has a conceptIds attribute, which should be a (String) commas-separated list of conceptIds)
   *          (Map<Integer, Concept>) conceptMap
   *          (Map<String, Concept>) conceptMapByStringIds
   * </pre>
   *
   * @should calculate bmi into patientBmiAsString
   * @should not fail with empty height and weight properties
   */
  @SuppressWarnings("unchecked")
  public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    AdministrationService as = Context.getAdministrationService();
    ConceptService cs = Context.getConceptService();

    // find the portlet that was identified in the openmrs:portlet taglib
    Object uri = request.getAttribute("javax.servlet.include.servlet_path");
    String portletPath = "";
    Map<String, Object> model = null;
    {
      HttpSession session = request.getSession();
      String uniqueRequestId = (String) request.getAttribute(WebConstants.INIT_REQ_UNIQUE_ID);
      String lastRequestId =
          (String) session.getAttribute(WebConstants.OPENMRS_PORTLET_LAST_REQ_ID);
      if (uniqueRequestId.equals(lastRequestId)) {
        model =
            (Map<String, Object>) session.getAttribute(WebConstants.OPENMRS_PORTLET_CACHED_MODEL);

        // remove cached parameters
        List<String> parameterKeys = (List<String>) model.get("parameterKeys");
        for (String key : parameterKeys) {
          model.remove(key);
        }
      }
      if (model == null) {
        log.debug("creating new portlet model");
        model = new HashMap<String, Object>();
        session.setAttribute(WebConstants.OPENMRS_PORTLET_LAST_REQ_ID, uniqueRequestId);
        session.setAttribute(WebConstants.OPENMRS_PORTLET_CACHED_MODEL, model);
      }
    }

    if (uri != null) {
      long timeAtStart = System.currentTimeMillis();
      portletPath = uri.toString();

      // Allowable extensions are '' (no extension) and '.portlet'
      if (portletPath.endsWith("portlet")) portletPath = portletPath.replace(".portlet", "");
      else if (portletPath.endsWith("jsp"))
        throw new ServletException(
            "Illegal extension used for portlet: '.jsp'. Allowable extensions are '' (no extension) and '.portlet'");

      log.debug("Loading portlet: " + portletPath);

      String id = (String) request.getAttribute("org.openmrs.portlet.id");
      String size = (String) request.getAttribute("org.openmrs.portlet.size");
      Map<String, Object> params =
          (Map<String, Object>) request.getAttribute("org.openmrs.portlet.parameters");
      Map<String, Object> moreParams =
          (Map<String, Object>) request.getAttribute("org.openmrs.portlet.parameterMap");

      model.put("now", new Date());
      model.put("id", id);
      model.put("size", size);
      model.put("locale", Context.getLocale());
      model.put("portletUUID", UUID.randomUUID().toString().replace("-", ""));
      List<String> parameterKeys = new ArrayList<String>(params.keySet());
      model.putAll(params);
      if (moreParams != null) {
        model.putAll(moreParams);
        parameterKeys.addAll(moreParams.keySet());
      }
      model.put("parameterKeys", parameterKeys); // so we can clean these up in the next request

      // if there's an authenticated user, put them, and their patient set, in the model
      if (Context.getAuthenticatedUser() != null) {
        model.put("authenticatedUser", Context.getAuthenticatedUser());
      }

      Integer personId = null;

      // if a patient id is available, put patient data documented above in the model
      Object o = request.getAttribute("org.openmrs.portlet.patientId");
      if (o != null) {
        String patientVariation = "";
        Integer patientId = (Integer) o;
        if (!model.containsKey("patient")) {
          // we can't continue if the user can't view patients
          if (Context.hasPrivilege(PrivilegeConstants.VIEW_PATIENTS)) {
            Patient p = Context.getPatientService().getPatient(patientId);
            model.put("patient", p);

            // add encounters if this user can view them
            if (Context.hasPrivilege(PrivilegeConstants.VIEW_ENCOUNTERS))
              model.put(
                  "patientEncounters", Context.getEncounterService().getEncountersByPatient(p));

            if (Context.hasPrivilege(PrivilegeConstants.VIEW_OBS)) {
              List<Obs> patientObs = Context.getObsService().getObservationsByPerson(p);
              model.put("patientObs", patientObs);
              Obs latestWeight = null;
              Obs latestHeight = null;
              String bmiAsString = "?";
              try {
                String weightString = as.getGlobalProperty("concept.weight");
                ConceptNumeric weightConcept = null;
                if (StringUtils.hasLength(weightString))
                  weightConcept =
                      cs.getConceptNumeric(
                          cs.getConcept(Integer.valueOf(weightString)).getConceptId());
                String heightString = as.getGlobalProperty("concept.height");
                ConceptNumeric heightConcept = null;
                if (StringUtils.hasLength(heightString))
                  heightConcept =
                      cs.getConceptNumeric(
                          cs.getConcept(Integer.valueOf(heightString)).getConceptId());
                for (Obs obs : patientObs) {
                  if (obs.getConcept().equals(weightConcept)) {
                    if (latestWeight == null
                        || obs.getObsDatetime().compareTo(latestWeight.getObsDatetime()) > 0)
                      latestWeight = obs;
                  } else if (obs.getConcept().equals(heightConcept)) {
                    if (latestHeight == null
                        || obs.getObsDatetime().compareTo(latestHeight.getObsDatetime()) > 0)
                      latestHeight = obs;
                  }
                }
                if (latestWeight != null) model.put("patientWeight", latestWeight);
                if (latestHeight != null) model.put("patientHeight", latestHeight);
                if (latestWeight != null && latestHeight != null) {
                  double weightInKg;
                  double heightInM;
                  if (weightConcept.getUnits().equals("kg"))
                    weightInKg = latestWeight.getValueNumeric();
                  else if (weightConcept.getUnits().equals("lb"))
                    weightInKg = latestWeight.getValueNumeric() * 0.45359237;
                  else
                    throw new IllegalArgumentException(
                        "Can't handle units of weight concept: " + weightConcept.getUnits());
                  if (heightConcept.getUnits().equals("cm"))
                    heightInM = latestHeight.getValueNumeric() / 100;
                  else if (heightConcept.getUnits().equals("m"))
                    heightInM = latestHeight.getValueNumeric();
                  else if (heightConcept.getUnits().equals("in"))
                    heightInM = latestHeight.getValueNumeric() * 0.0254;
                  else
                    throw new IllegalArgumentException(
                        "Can't handle units of height concept: " + heightConcept.getUnits());
                  double bmi = weightInKg / (heightInM * heightInM);
                  model.put("patientBmi", bmi);
                  String temp = "" + bmi;
                  bmiAsString = temp.substring(0, temp.indexOf('.') + 2);
                }
              } catch (Exception ex) {
                if (latestWeight != null && latestHeight != null)
                  log.error(
                      "Failed to calculate BMI even though a weight and height were found", ex);
              }
              model.put("patientBmiAsString", bmiAsString);
            } else {
              model.put("patientObs", new HashSet<Obs>());
            }

            // information about whether or not the patient has exited care
            Obs reasonForExitObs = null;
            String reasonForExitConceptString = as.getGlobalProperty("concept.reasonExitedCare");
            if (StringUtils.hasLength(reasonForExitConceptString)) {
              Concept reasonForExitConcept = cs.getConcept(reasonForExitConceptString);
              if (reasonForExitConcept != null) {
                List<Obs> patientExitObs =
                    Context.getObsService()
                        .getObservationsByPersonAndConcept(p, reasonForExitConcept);
                if (patientExitObs != null) {
                  log.debug("Exit obs is size " + patientExitObs.size());
                  if (patientExitObs.size() == 1) {
                    reasonForExitObs = patientExitObs.iterator().next();
                    Concept exitReason = reasonForExitObs.getValueCoded();
                    Date exitDate = reasonForExitObs.getObsDatetime();
                    if (exitReason != null && exitDate != null) {
                      patientVariation = "Exited";
                    }
                  } else {
                    if (patientExitObs.size() == 0) {
                      log.debug("Patient has no reason for exit");
                    } else {
                      log.error("Too many reasons for exit - not putting data into model");
                    }
                  }
                }
              }
            }
            model.put("patientReasonForExit", reasonForExitObs);

            if (Context.hasPrivilege(PrivilegeConstants.VIEW_ORDERS)) {
              List<DrugOrder> drugOrderList = Context.getOrderService().getDrugOrdersByPatient(p);
              model.put("patientDrugOrders", drugOrderList);
              List<DrugOrder> currentDrugOrders = new ArrayList<DrugOrder>();
              List<DrugOrder> discontinuedDrugOrders = new ArrayList<DrugOrder>();
              Date rightNow = new Date();
              for (Iterator<DrugOrder> iter = drugOrderList.iterator(); iter.hasNext(); ) {
                DrugOrder next = iter.next();
                if (next.isCurrent() || next.isFuture()) currentDrugOrders.add(next);
                if (next.isDiscontinued(rightNow)) discontinuedDrugOrders.add(next);
              }
              model.put("currentDrugOrders", currentDrugOrders);
              model.put("completedDrugOrders", discontinuedDrugOrders);

              List<RegimenSuggestion> standardRegimens =
                  Context.getOrderService().getStandardRegimens();
              if (standardRegimens != null) model.put("standardRegimens", standardRegimens);
            }

            if (Context.hasPrivilege(PrivilegeConstants.VIEW_PROGRAMS)
                && Context.hasPrivilege(PrivilegeConstants.VIEW_PATIENT_PROGRAMS)) {
              model.put(
                  "patientPrograms",
                  Context.getProgramWorkflowService()
                      .getPatientPrograms(p, null, null, null, null, null, false));
              model.put(
                  "patientCurrentPrograms",
                  Context.getProgramWorkflowService()
                      .getPatientPrograms(p, null, null, new Date(), new Date(), null, false));
            }

            model.put("patientId", patientId);
            if (p != null) {
              personId = p.getPatientId();
              model.put("personId", personId);
            }

            model.put("patientVariation", patientVariation);
          }
        }
      }

      // if a person id is available, put person and relationships in the model
      if (personId == null) {
        o = request.getAttribute("org.openmrs.portlet.personId");
        if (o != null) {
          personId = (Integer) o;
          model.put("personId", personId);
        }
      }
      if (personId != null) {
        if (!model.containsKey("person")) {
          Person p = (Person) model.get("patient");
          if (p == null) p = Context.getPersonService().getPerson(personId);
          model.put("person", p);

          if (Context.hasPrivilege(PrivilegeConstants.VIEW_RELATIONSHIPS)) {
            List<Relationship> relationships = new ArrayList<Relationship>();
            relationships.addAll(Context.getPersonService().getRelationshipsByPerson(p));
            Map<RelationshipType, List<Relationship>> relationshipsByType =
                new HashMap<RelationshipType, List<Relationship>>();
            for (Relationship rel : relationships) {
              List<Relationship> list = relationshipsByType.get(rel.getRelationshipType());
              if (list == null) {
                list = new ArrayList<Relationship>();
                relationshipsByType.put(rel.getRelationshipType(), list);
              }
              list.add(rel);
            }

            model.put("personRelationships", relationships);
            model.put("personRelationshipsByType", relationshipsByType);
          }
        }
      }

      // if an encounter id is available, put "encounter" and "encounterObs" in the model
      o = request.getAttribute("org.openmrs.portlet.encounterId");
      if (o != null && !model.containsKey("encounterId")) {
        if (!model.containsKey("encounter")) {
          if (Context.hasPrivilege(PrivilegeConstants.VIEW_ENCOUNTERS)) {
            Encounter e = Context.getEncounterService().getEncounter((Integer) o);
            model.put("encounter", e);
            if (Context.hasPrivilege(PrivilegeConstants.VIEW_OBS))
              model.put("encounterObs", e.getObs());
          }
          model.put("encounterId", (Integer) o);
        }
      }

      // if a user id is available, put "user" in the model
      o = request.getAttribute("org.openmrs.portlet.userId");
      if (o != null) {
        if (!model.containsKey("user")) {
          if (Context.hasPrivilege(PrivilegeConstants.VIEW_USERS)) {
            User u = Context.getUserService().getUser((Integer) o);
            model.put("user", u);
          }
          model.put("userId", (Integer) o);
        }
      }

      // if a list of patient ids is available, make a patientset out of it
      o = request.getAttribute("org.openmrs.portlet.patientIds");
      if (o != null && !"".equals(o) && !model.containsKey("patientIds")) {
        if (!model.containsKey("patientSet")) {
          Cohort ps = new Cohort((String) o);
          model.put("patientSet", ps);
          model.put("patientIds", (String) o);
        }
      }

      o = model.get("conceptIds");
      if (o != null && !"".equals(o)) {
        if (!model.containsKey("conceptMap")) {
          log.debug("Found conceptIds parameter: " + o);
          Map<Integer, Concept> concepts = new HashMap<Integer, Concept>();
          Map<String, Concept> conceptsByStringIds = new HashMap<String, Concept>();
          String conceptIds = (String) o;
          String[] ids = conceptIds.split(",");
          for (String cId : ids) {
            try {
              Integer i = Integer.valueOf(cId);
              Concept c = cs.getConcept(i);
              concepts.put(i, c);
              conceptsByStringIds.put(i.toString(), c);
            } catch (Exception ex) {
            }
          }
          model.put("conceptMap", concepts);
          model.put("conceptMapByStringIds", conceptsByStringIds);
        }
      }

      populateModel(request, model);
      log.debug(portletPath + " took " + (System.currentTimeMillis() - timeAtStart) + " ms");
    }

    return new ModelAndView(portletPath, "model", model);
  }