コード例 #1
0
 private static boolean regimenComponentIsTheSameAsDrugOrderExcludingDates(
     DrugOrder rc, DrugOrder doTmp) {
   if (rc.getDrug() != null
       && doTmp.getDrug() != null
       && rc.getDrug().getDrugId().intValue() != doTmp.getDrug().getDrugId().intValue())
     return false;
   if (!OpenmrsUtil.nullSafeEquals(rc.getConcept(), doTmp.getConcept())) return false;
   if (!OpenmrsUtil.nullSafeEquals(rc.getDose(), doTmp.getDose())) return false;
   if (!OpenmrsUtil.nullSafeEquals(rc.getFrequency(), doTmp.getFrequency())) return false;
   if (!OpenmrsUtil.nullSafeEquals(rc.getUnits(), doTmp.getUnits())) return false;
   return true;
 }
コード例 #2
0
 private static boolean drugOrderMatchesDrugConcept(DrugOrder rc, DrugOrder doTmp) {
   if (rc.getDrug() != null
       && (doTmp.getDrug() != null
               && rc.getDrug().getConcept().equals(doTmp.getDrug().getConcept())
           || (doTmp.getConcept() != null
               && rc.getDrug().getConcept().equals(doTmp.getConcept())))) return true;
   if (doTmp.getDrug() != null
       && (rc.getDrug() != null && doTmp.getDrug().getConcept().equals(rc.getDrug().getConcept())
           || (rc.getConcept() != null && doTmp.getDrug().getConcept().equals(rc.getConcept()))))
     return true;
   if (doTmp.getConcept() != null
       && rc.getConcept() != null
       && doTmp.getConcept().equals(rc.getConcept())) return true;
   return false;
 }
  @Test
  public void shouldAddNewDrugOrderWhenPrnIsTrueWIthNoDosageFrequencyOrDosageInstruction() {

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

    when(orderService.getAllOrderTypes()).thenReturn(asList(drugOrderType));
    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(today, order.getStartDate());
    assertEquals(today, order.getAutoExpireDate());
    assertEquals(drug.getDisplayName(), order.getDrug().getDisplayName());
    assertEquals(Double.valueOf(3), order.getDose());

    assertEquals(true, order.getPrn());
    assertEquals(null, order.getFrequency());
    assertEquals(null, order.getUnits());
  }
コード例 #4
0
  @Test
  public void shouldAddNewDrugOrder() throws Exception {
    executeDataSet("shouldAddNewDrugOrder.xml");

    String json =
        "{ \"patientUuid\" : \"a76e8d23-0c38-408c-b2a8-ea5540f01b51\", "
            + "\"visitTypeUuid\" : \"b45ca846-c79a-11e2-b0c0-8e397087571c\", "
            + "\"encounterTypeUuid\": \"2b377dba-62c3-4e53-91ef-b51c68899890\", "
            + "\"encounterDateTime\" : \"2005-01-02T00:00:00.000+0000\", "
            + "\"testOrders\":["
            + "{\"concept\":{ \"uuid\": \"d102c80f-1yz9-4da3-bb88-8122ce8868dd\"}, "
            + "\"instructions\":\"do it\", \"orderTypeUuid\": \"1a61ef2a-250c-11e3-b832-0800271c1b75\" }],"
            + "\"drugOrders\":["
            + "{\"uuid\": \"4d6fb6e0-4950-426c-9a9b-1f97e6037893\","
            + "\"concept\": {\"uuid\": \"29dc4a20-507f-40ed-9545-d47e932483fa\"},"
            + "\"notes\": \"Take as needed\","
            + "\"startDate\": \"2013-09-30T09:26:09.717Z\","
            + "\"endDate\": \"2013-10-02T09:26:09.717Z\","
            + "\"numberPerDosage\": 1,"
            + "\"dosageInstruction\": {\"uuid\": \"632aa422-2696-11e3-895c-0800271c1b75\"},"
            + "\"dosageFrequency\": {\"uuid\": \"6302096d-2696-11e3-895c-0800271c1b75\"},"
            + "\"prn\": true}"
            + "]}";

    EncounterTransaction response =
        deserialize(
            handle(newPostRequest("/rest/emrapi/encounter", json)), EncounterTransaction.class);

    Visit visit = visitService.getVisitByUuid(response.getVisitUuid());
    Encounter encounter = visit.getEncounters().iterator().next();
    assertEquals(2, encounter.getOrders().size());

    List<Order> orders = new ArrayList<Order>(encounter.getOrders());

    List<DrugOrder> drugOrders = getOrdersOfType(orders, DrugOrder.class);
    assertEquals(1, drugOrders.size());
    DrugOrder drugOrder = drugOrders.get(0);
    assertEquals("a76e8d23-0c38-408c-b2a8-ea5540f01b51", drugOrder.getPatient().getUuid());
    assertEquals("f13d6fae-baa9-4553-955d-920098bec08f", drugOrder.getEncounter().getUuid());
    assertEquals("29dc4a20-507f-40ed-9545-d47e932483fa", drugOrder.getConcept().getUuid());
    assertEquals("1a61ef2a-250c-11e3-b832-9876541c1b75", drugOrder.getOrderType().getUuid());
    assertEquals("Take as needed", drugOrder.getInstructions());
    assertEquals(new DateTime("2013-09-30T09:26:09.717Z").toDate(), drugOrder.getStartDate());
    assertEquals(new DateTime("2013-10-02T09:26:09.717Z").toDate(), drugOrder.getAutoExpireDate());
    assertEquals("6302096d-2696-11e3-895c-0800271c1b75", drugOrder.getFrequency());
    assertEquals("632aa422-2696-11e3-895c-0800271c1b75", drugOrder.getUnits());
    assertEquals("test drug", drugOrder.getDrug().getDisplayName());
    assertEquals(Double.valueOf(1), drugOrder.getDose());
    assertEquals(true, drugOrder.getPrn());

    List<TestOrder> testOrders = getOrdersOfType(orders, TestOrder.class);
    assertEquals(1, testOrders.size());
    TestOrder testOrder = testOrders.get(0);
    assertEquals("d102c80f-1yz9-4da3-bb88-8122ce8868dd", testOrder.getConcept().getUuid());
    assertEquals("a76e8d23-0c38-408c-b2a8-ea5540f01b51", testOrder.getPatient().getUuid());
    assertEquals("f13d6fae-baa9-4553-955d-920098bec08f", testOrder.getEncounter().getUuid());
    assertEquals("1a61ef2a-250c-11e3-b832-0800271c1b75", testOrder.getOrderType().getUuid());
    assertEquals("do it", testOrder.getInstructions());
  }
コード例 #5
0
  @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;
  }
  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;
  }
コード例 #7
0
  /**
   * @verifies not require all fields for a discontinuation order
   * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
   */
  @Test
  public void validate_shouldNotRequireAllFieldsForADiscontinuationOrder() throws Exception {
    DrugOrder orderToDiscontinue = (DrugOrder) Context.getOrderService().getOrder(111);
    assertTrue(OrderUtilTest.isActiveOrder(orderToDiscontinue, null));
    DrugOrder discontinuationOrder = new DrugOrder();
    discontinuationOrder.setDosingType(null);
    discontinuationOrder.setCareSetting(orderToDiscontinue.getCareSetting());
    discontinuationOrder.setConcept(orderToDiscontinue.getConcept());
    discontinuationOrder.setAction(Order.Action.DISCONTINUE);
    discontinuationOrder.setPreviousOrder(orderToDiscontinue);
    discontinuationOrder.setPatient(orderToDiscontinue.getPatient());
    discontinuationOrder.setDrug(orderToDiscontinue.getDrug());
    discontinuationOrder.setOrderType(orderToDiscontinue.getOrderType());
    discontinuationOrder.setOrderer(Context.getProviderService().getProvider(1));
    discontinuationOrder.setEncounter(Context.getEncounterService().getEncounter(3));

    Errors errors = new BindException(discontinuationOrder, "order");
    new DrugOrderValidator().validate(discontinuationOrder, errors);
    Assert.assertFalse(errors.hasErrors());
  }
  protected ModelAndView handleRequestInternal(
      HttpServletRequest request, HttpServletResponse response) throws Exception {

    ModelAndView mav = new ModelAndView();

    Drug drug = null;
    Location dftLoc = null;
    LocationService locationService = Context.getLocationService();

    String locationStr =
        Context.getAuthenticatedUser()
            .getUserProperties()
            .get(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCATION);

    try {
      dftLoc = locationService.getLocation(Integer.valueOf(locationStr));
    } catch (Exception e) {
      mav.addObject("msg", "pharmacymanagement.missingDftLoc");
    }
    @SuppressWarnings("unused")
    String pharmacyId = null;
    DrugLotDate dld = null;
    List<DrugLotDate> dlds = new ArrayList<DrugLotDate>();
    String patientIdStr = null;
    Patient patient = null;
    DrugOrderService service = Context.getService(DrugOrderService.class);
    List<Pharmacy> pharmacyList = service.getPharmacyByLocation(dftLoc);
    List<DrugOrder> drugOrders = new ArrayList<DrugOrder>();
    ConceptService conceptService = Context.getConceptService();
    Pharmacy pharmacy = null;

    List<DrugOrder> drugOrderList = new ArrayList<DrugOrder>();
    pharmacyId = pharmacyList.size() > 0 ? "not empty" : "";

    if (request.getParameter("patientId") != null
        && !request.getParameter("patientId").equals("")) {
      patientIdStr = request.getParameter("patientId");

      patient = Context.getPatientService().getPatient(Integer.valueOf(patientIdStr));
    }

    if (patient != null
        && request.getParameter("pharmacyId") != null
        && !request.getParameter("pharmacyId").equals("")) {

      drugOrders = Context.getOrderService().getDrugOrdersByPatient(patient);

      pharmacy = service.getPharmacyById(Integer.valueOf(request.getParameter("pharmacyId")));
      List<Integer> drugIdList = new ArrayList<Integer>();
      for (DrugOrder dor : drugOrders) {
        if (dor.getDiscontinued() == false) {
          drugOrderList.add(dor);
        }
      }

      Set<DrugProduct> lotNos = new HashSet<DrugProduct>();
      int solde = 0;

      List<Integer> drugIdss = new ArrayList<Integer>();
      List<DrugOrder> drugOrders1 = new ArrayList<DrugOrder>();
      for (DrugOrder drOr : drugOrderList) {
        if (!drugIdss.contains(drOr.getDrug().getDrugId()) && drOr.getAutoExpireDate() == null) {
          dld = new DrugLotDate();
          drugOrders1.add(drOr);
          drugIdList.add(drOr.getDrug().getDrugId());

          dld.setDrugOrder(drOr);
          drug = conceptService.getDrug(drOr.getDrug().getDrugId());
          dld.setDrug(drug);
          Map<String, String> dpMap = new HashMap<String, String>();
          lotNos =
              Utils.getLotsExpDp(
                  null, drOr.getDrug().getDrugId() + "", null, pharmacy.getPharmacyId() + "");

          /**
           * TO DO change this list of lotNos by the testLots in the Utils class remember to
           * retrieve a list of list instead of a unique set!!!!!!!!!!!!!!!!
           */
          if (lotNos.size() > 0) {
            for (DrugProduct drugproduct : lotNos) {
              if (drug != null)
                solde =
                    service.getCurrSoldeDisp(
                        drug.getDrugId() + "",
                        null,
                        pharmacy.getPharmacyId() + "",
                        drugproduct.getExpiryDate() + "",
                        drugproduct.getLotNo(),
                        null);

              if (solde != 0) {
                dpMap.put(
                    drugproduct.getLotNo()
                        + " / "
                        + solde
                        + " ("
                        + drugproduct.getExpiryDate()
                        + ") ",
                    drugproduct.getDrugproductId() + "");
                dld.setDpMap(dpMap);
              }
            }
            if (dpMap.size() > 0) dlds.add(dld);
          }
        }
        drugIdss.add(drOr.getDrug().getDrugId());
      }

      mav.addObject("patient", patient);
    }

    if (dlds.size() != 0) {
      mav.addObject("dlds", dlds);
    }

    List<Object[]> lots = null;
    DrugProduct drugproduct = null;
    if (request.getParameter("drugproductId") != null
        && !request.getParameter("drugproductId").equals("")) {
      drugproduct =
          service.getDrugProductById(Integer.valueOf(request.getParameter("drugproductId")));
      if (drugproduct != null) {
        if (drugproduct.getCmddrugId() != null) {
          if (drugproduct.getCmddrugId().getDestination().getLocationId()
              == dftLoc.getLocationId()) {
            if (drugproduct.getDrugId() != null)
              lots =
                  service.getLotNumbersExpirationDates(
                      drugproduct.getDrugId().getDrugId() + "",
                      null,
                      dftLoc.getLocationId() + "",
                      null);
            else
              lots =
                  service.getLotNumbersExpirationDates(
                      null,
                      drugproduct.getConceptId().getConceptId() + "",
                      dftLoc.getLocationId() + "",
                      null);
          }
        } else {
          if (service.getReturnStockByDP(drugproduct).get(0).getDestination().getLocationId()
              == dftLoc.getLocationId()) {
            if (drugproduct.getDrugId() != null)
              lots =
                  service.getLotNumbersExpirationDates(
                      drugproduct.getDrugId().getDrugId() + "",
                      null,
                      dftLoc.getLocationId() + "",
                      null);
            else
              lots =
                  service.getLotNumbersExpirationDates(
                      null,
                      drugproduct.getConceptId().getConceptId() + "",
                      dftLoc.getLocationId() + "",
                      null);
          }
        }
      }
      mav.addObject("lots", lots);
    }

    if (request.getParameter("dpFromGet") != null
        && !request.getParameter("dpFromGet").equals("")) {
      DrugProduct dp =
          service.getDrugProductById(Integer.valueOf(request.getParameter("dpFromGet")));
      String dateStr = dp.getExpiryDate().toString();
      String[] dateArr = dateStr.split("-");
      String date = dateArr[2] + "/" + dateArr[1] + "/" + dateArr[0];
      mav.addObject("date", date);
    }

    mav.setViewName(getViewName());
    return mav;
  }