/**
  * Creates a new person stub.
  *
  * @param given
  * @param middle
  * @param family
  * @param birthdate
  * @param dateformat
  * @param age
  * @param gender
  * @return PersonListItem person stub created
  */
 public Object createPerson(
     String given,
     String middle,
     String family,
     String birthdate,
     String dateformat,
     String age,
     String gender) {
   log.error(
       given
           + " "
           + middle
           + " "
           + family
           + " "
           + birthdate
           + " "
           + dateformat
           + " "
           + age
           + " "
           + gender);
   User user = Context.getAuthenticatedUser();
   Person p = new Person();
   p.setPersonCreator(user);
   p.setPersonDateCreated(new Date());
   p.setPersonChangedBy(user);
   p.setPersonDateChanged(new Date());
   if (StringUtils.isEmpty(gender)) {
     log.error("Gender cannot be null.");
     return String.valueOf("Gender cannot be null.");
   } else if (gender.toUpperCase().contains("M")) {
     p.setGender("M");
   } else if (gender.toUpperCase().contains("F")) {
     p.setGender("F");
   } else {
     log.error("Gender must be 'M' or 'F'.");
     return new String("Gender must be 'M' or 'F'.");
   }
   if ("".equals(given) || "".equals(family)) {
     log.error("Given name and family name cannot be null.");
     return new String("Given name and family name cannot be null.");
   }
   PersonName name = new PersonName(given, middle, family);
   name.setCreator(user);
   name.setDateCreated(new Date());
   name.setChangedBy(user);
   name.setDateChanged(new Date());
   p.addName(name);
   try {
     Date d = updateAge(birthdate, dateformat, age);
     p.setBirthdate(d);
   } catch (java.text.ParseException pe) {
     log.error(pe);
     return new String("Birthdate cannot be parsed.");
   }
   p.setGender(gender);
   Person person = Context.getPersonService().savePerson(p);
   return PersonListItem.createBestMatch(person);
 }
 private void setParentId(Patient patient, Relationship motherRelationship) {
   Person mother = motherRelationship.getPersonA();
   if (mother != null && !mother.getNames().isEmpty()) {
     List<Patient> patients =
         allPatients.search(mother.getNames().iterator().next().getFullName(), null);
     if (patients != null && !patients.isEmpty()) {
       patient.parentId(getParentId(mother, patients));
     }
   }
 }
Пример #3
0
  private static String getPatientIdentifier(Person person) throws Exception {
    try {
      Patient patient = Context.getPatientService().getPatient(person.getPersonId());
      if (getPersonId(patient) == person.getPersonId()) {
        return patient.getPatientIdentifier().getIdentifier();
      }
    } catch (Exception ex) {
      log.error(ex.getMessage(), ex);
    }

    return "";
  }
 private void updateRelationship(String parentId, Patient savedPatient, Relationship relationship)
     throws ParentNotFoundException {
   Patient updatedMother = getPatientByMotechId(parentId);
   if (updatedMother == null) {
     throw new ParentNotFoundException();
   }
   Person personA = relationship.getPersonA();
   if (personA != null
       && !personA.getId().toString().equals(updatedMother.getMrsPatient().getPerson().getId())) {
     allPatients.updateMotherChildRelationship(
         updatedMother.getMrsPatient().getPerson(), savedPatient.getMrsPatient().getPerson());
   }
 }
 /**
  * This method exists to allow us to quickly support providers as introduce in OpenMRS 1.9.x,
  * without having to branch the module. We should remove this method when do a proper
  * implementation.
  *
  * @return personIds of all providers that are attached to persons
  */
 private Set<Integer> getAllProviderPersonIds() {
   try {
     Set<Integer> ret = new HashSet<Integer>();
     for (Object candidate : getAllProvidersThatArePersons()) {
       Person person = (Person) PropertyUtils.getProperty(candidate, "person");
       if (person != null) ret.add(person.getPersonId());
     }
     return ret;
   } catch (Exception ex) {
     throw new RuntimeException(
         "Programming error in HTML Form Entry module. This method should be safe!", ex);
   }
 }
  public static String getFullPersonAddress(Person p) {

    String address = "-/-/-/-/-/-";
    try {
      //			Country/Province/District/Sector/Cell/Umudugudu
      PersonAddress pa = null;
      if (p != null) pa = p.getPersonAddress();
      if (pa != null) {
        address =
            ((pa.getCountry() != null) ? pa.getCountry() : "-")
                + " / "
                + ((pa.getStateProvince() != null) ? pa.getStateProvince() : "-")
                + " / "
                + ((pa.getCountyDistrict() != null) ? pa.getCountyDistrict() : "-")
                + " / "
                + ((pa.getCityVillage() != null) ? pa.getCityVillage() : "-")
                + " / "
                + ((pa.getNeighborhoodCell() != null) ? pa.getNeighborhoodCell() : "-")
                + " / "
                + ((pa.getAddress1() != null) ? pa.getAddress1() : "-");
      } else return address;
      return address;
    } catch (Exception e) {
      log.error(">>>>>>>>>>>>>>>>>>>VCT>>Module>>Tag>>>> An error occured : " + e.getMessage());
      e.printStackTrace();
      return address;
    }
  }
 private String getParentId(Person mother, List<Patient> patients) {
   for (Patient patient : patients) {
     if (patient.getMrsPatient().getPerson().getId().equals(mother.getId().toString())) {
       return patient.getMrsPatient().getMotechId();
     }
   }
   return null;
 }
  /**
   * Auto generated method comment
   *
   * @param personId
   * @return
   */
  public static String getPersonNames(Integer personId) {
    try {
      if (personId == null) return "";

      Person person = Context.getPersonService().getPerson(personId);
      String names = "";
      if (null != person) {
        names =
            (person.getGivenName().trim() + " " + person.getMiddleName()).trim()
                + " "
                + person.getFamilyName().trim();
      }
      return names;
    } catch (Exception e) {
      log.info(e.getMessage());
      return "";
    }
  }
  public static Integer getProviderId(String userName) {
    User userProvider;
    Person personProvider;

    // assume its a normal user-name or systemId formatted with a dash
    userProvider = Context.getUserService().getUserByUsername(userName);
    if (userProvider != null) {
      return userProvider.getPerson().getPersonId();
    }

    // next assume it is a internal providerId (Note this is a person_id
    // not a user_id) and try again
    try {
      personProvider = Context.getPersonService().getPerson(Integer.parseInt(userName));
      if (personProvider != null) {
        return personProvider.getPersonId();
      }
    } catch (NumberFormatException e) {
      e.printStackTrace();
    }

    // now assume its a systemId without a dash: fix the dash and try again
    if (userName != null && userName.trim() != "") {
      if (userName.indexOf("-") == -1 && userName.length() > 1) {
        userName =
            userName.substring(0, userName.length() - 1)
                + "-"
                + userName.substring(userName.length() - 1);
        userProvider = Context.getUserService().getUserByUsername(userName);
        if (userProvider != null) {
          return userProvider.getPerson().getPersonId();
        }
      }
    }

    return null;
  }
 /**
  * Auto generated method comment
  *
  * @param p
  * @param attributeTypeId
  * @return
  */
 public static String personAttribute(Person p, Integer attributeTypeId) {
   try {
     PersonAttribute pa = null;
     if (p != null) pa = p.getAttribute(attributeTypeId);
     if (pa != null) {
       return Context.getConceptService()
           .getConcept(Integer.parseInt(pa.getValue()))
           .getName()
           .getName();
     } else return "-";
   } catch (Exception e) {
     log.error(">>>>>>>>>>>>>>>>>>>VCT>>Module>>Tag>>>> An error occured : " + e.getMessage());
     e.printStackTrace();
     return "-";
   }
 }
 /**
  * Auto generated method comment
  *
  * @param p
  * @param addressTypeId
  * @return
  */
 public static String personAddress(Person p, Integer addressTypeId) {
   try {
     PersonAddress pa = null;
     if (p != null) pa = p.getPersonAddress();
     if (pa != null) {
       switch (addressTypeId) {
         case 1:
           return (pa.getAddress1().compareToIgnoreCase("") == 0) ? "-" : pa.getAddress1();
         case 2:
           return (pa.getAddress2().compareToIgnoreCase("") == 0) ? "-" : pa.getAddress2();
         case 3:
           return (pa.getCityVillage().compareToIgnoreCase("") == 0) ? "-" : pa.getCityVillage();
         default:
           return "-";
       }
     } else return "-";
   } catch (Exception e) {
     log.error(">>>>>>>>>>>>>>>>>>>VCT>>Module>>Tag>>>> An error occured : " + e.getMessage());
     e.printStackTrace();
     return "-";
   }
 }
Пример #12
0
  /**
   * Checks the form object for any inconsistencies/errors
   *
   * @see org.springframework.validation.Validator#validate(java.lang.Object,
   *     org.springframework.validation.Errors)
   * @should fail validation if retired and retireReason is null or empty or whitespace
   * @should pass validation if all required fields have proper values
   */
  public void validate(Object obj, Errors errors) {
    User user = (User) obj;
    if (user == null) {
      errors.rejectValue("user", "error.general");
    } else {
      if (user.isRetired() && !StringUtils.hasText(user.getRetireReason()))
        errors.rejectValue("retireReason", "error.null");
      if (user.getPerson() == null) {
        errors.rejectValue("person", "error.null");
      } else {
        // check that required person details are filled out
        Person person = user.getPerson();
        if (person.getGender() == null) errors.rejectValue("person.gender", "error.null");
        if (person.getDead() == null) errors.rejectValue("person.dead", "error.null");
        if (person.getVoided() == null) errors.rejectValue("person.voided", "error.null");
        if (person.getPersonName() == null
            || !StringUtils.hasText(person.getPersonName().toString()))
          errors.rejectValue("person", "Person.names.length");
      }
    }

    if (!isUserNameValid(user.getUsername()))
      errors.rejectValue("username", "error.username.pattern");
  }
Пример #13
0
 /** Gets the value of an attribute on a person. */
 public static String getPersonAttributeValue(Person person, PersonAttributeType attrType) {
   PersonAttribute attribute = person.getAttribute(attrType);
   return attribute != null ? attribute.getValue() : null;
 }
  @Test
  public void shouldEvaluateOBRORUR01TemplateForOBSGroup() throws Exception {
    // given
    Encounter encounter = new Encounter();

    Date date = new Date();
    encounter.setEncounterDatetime(date);
    encounter.setUuid("ENCOUNTER UUID");

    EncounterType encounterType = new EncounterType();
    encounterType.setName("ENCOUNTER TYPE NAME");
    encounter.setEncounterType(encounterType);

    Location location = new Location(1);
    location.setUuid("LOCATION UUID");
    location.setName("LOCATION NAME");
    encounter.setLocation(location);

    Person provider = new Person(1);
    provider.setUuid("PROVIDER UUID");
    provider.addName(
        new PersonName("PROVIDER GIVENNAME", "PROVIDER MIDDLENAME", "PROVIDER FAMILYNAME"));
    encounter.setProvider(provider);

    ConceptSource source = new ConceptSource();
    source.setName("AMPATH");

    ConceptMap map = new ConceptMap();
    map.setSourceCode("200");
    map.setSource(source);

    ConceptDatatype datatype = new ConceptDatatype();
    datatype.setUuid(ConceptDatatype.NUMERIC_UUID);
    datatype.setHl7Abbreviation(ConceptDatatype.NUMERIC);

    ConceptNumeric concept = new ConceptNumeric();
    concept.setDatatype(datatype);
    concept.addConceptMapping(map);
    concept.addName(new ConceptName("NumericConcept", Locale.ENGLISH));
    concept.setUnits("mg");

    Date dateCreated = new Date(213231421890234L);

    Obs obs = new Obs(2);
    obs.setConcept(concept);
    obs.setDateCreated(dateCreated);
    obs.setValueNumeric(10d);

    obs.setObsGroup(getObsGroup());
    obs.getObsGroup().addGroupMember(obs);

    encounter.addObs(obs);

    obs = new Obs(3);
    obs.setConcept(concept);
    obs.setDateCreated(dateCreated);
    obs.setValueNumeric(23d);
    encounter.addObs(obs);

    Map<String, Object> bindings = new HashMap<String, Object>();
    bindings.put("encounter", encounter);
    bindings.put("implementationId", "MVP");

    // when
    HL7Template hl7Template = hl7QueryService.getHL7TemplateByName("Generic Obs Group");
    String evaluatedTemplate = hl7QueryService.evaluateTemplate(hl7Template, bindings);

    // then
    evaluatedTemplate = StringUtils.deleteWhitespace(evaluatedTemplate);
    Assert.assertEquals(
        "<ORU_R01.ORDER_OBSERVATION><OBR><OBR.1>0</OBR.1><OBR.4><CE.1>100</CE.1>"
            + "<CE.2>MEDICALRECORDOBSERVATIONS</CE.2><CE.3>LOCAL</CE.3></OBR.4><OBR.18>0</OBR.18>"
            + "<OBR.29><EIP.2><EI.3>ENCOUNTERUUID</EI.3></EIP.2></OBR.29></OBR><ORU_R01.OBSERVATION>"
            + "<OBX><OBX.1>1</OBX.1><OBX.2>NM</OBX.2><OBX.3><CE.1>200</CE.1><CE.2>NumericConcept</CE.2>"
            + "<CE.3>AMPATH</CE.3></OBX.3><OBX.5>23.0</OBX.5><OBX.6><CE.1>mg</CE.1><CE.3>UCUM</CE.3></OBX.6>"
            + "<OBX.14><TS.1>"
            + new HL7TemplateFunctions().formatDate(dateCreated, null)
            + "</TS.1>"
            + "</OBX.14></OBX></ORU_R01.OBSERVATION></ORU_R01.ORDER_OBSERVATION>"
            + "<ORU_R01.ORDER_OBSERVATION><OBR><OBR.1>2</OBR.1><OBR.4><CE.1>100</CE.1><CE.2>MedSet</CE.2>"
            + "<CE.3>LOCAL</CE.3></OBR.4><OBR.18>0</OBR.18><OBR.29><EIP.2><EI.3>ENCOUNTERUUID</EI.3></EIP.2></OBR.29"
            + "></OBR><ORU_R01.OBSERVATION><OBX><OBX.1>2</OBX.1><OBX.2>NM</OBX.2><OBX.3><CE.1>200</CE.1>"
            + "<CE.2>NumericConcept</CE.2><CE.3>AMPATH</CE.3></OBX.3><OBX.5>10.0</OBX.5><OBX.6><CE.1>mg</CE.1>"
            + "<CE.3>UCUM</CE.3></OBX.6><OBX.14><TS.1>"
            + new HL7TemplateFunctions().formatDate(dateCreated, null)
            + "</TS.1></OBX.14></OBX></ORU_R01.OBSERVATION></ORU_R01.ORDER_OBSERVATION>",
        evaluatedTemplate);
  }
Пример #15
0
  private static String replaceIdsWithUuidsHelper(
      String formXmlData, String attribute, String objectType) {
    // pattern to find the specified attribute and pull out its values; regex matches any characters
    // within quotes after an equals, i.e. ="a2-32" would match a232
    Pattern substitutionPattern =
        Pattern.compile(attribute + "=\"(.*?)\"", Pattern.CASE_INSENSITIVE);
    Matcher matcher = substitutionPattern.matcher(formXmlData);

    // list to keep track of any "repeat" keys we are going to have to substitute out as well
    Set<String> keysToReplace = new HashSet<String>();

    StringBuffer buffer = new StringBuffer();

    while (matcher.find()) {
      // split the group into the various ids
      String[] ids = matcher.group(1).split(",");

      StringBuffer idBuffer = new StringBuffer();
      // now loop through each id
      for (String id : ids) {
        // see if this is a concept id (i.e., is made up of one or more digits), as opposed to a
        // mapping id or a uuid, or a key used in a repeat template)
        if (id.matches("^\\d+$")) {
          // now we need to fetch the appropriate object for this id, and append the uuid to the
          // buffer
          if ("concept".equalsIgnoreCase(objectType)) {
            Concept concept = Context.getConceptService().getConcept(Integer.valueOf(id));
            idBuffer.append(concept.getUuid() + ",");
          } else if ("location".equalsIgnoreCase(objectType)) {
            Location location = Context.getLocationService().getLocation(Integer.valueOf(id));
            idBuffer.append(location.getUuid() + ",");
          } else if ("program".equalsIgnoreCase(objectType)) {
            Program program = Context.getProgramWorkflowService().getProgram(Integer.valueOf(id));
            idBuffer.append(program.getUuid() + ",");
          } else if ("person".equalsIgnoreCase(objectType)) {
            Person person = Context.getPersonService().getPerson(Integer.valueOf(id));
            idBuffer.append(person.getUuid() + ",");
          }
        } else {
          // otherwise, leave the id only
          idBuffer.append(id + ",");

          // also, if this id is a key (i.e., something in curly braces) we need to keep track of it
          // so that we can perform key substitutions
          // pattern matches one or more characters of any type within curly braces
          Matcher keyMatcher = Pattern.compile("\\{(.+)\\}").matcher(id);
          if (keyMatcher.find()) {
            keysToReplace.add(keyMatcher.group(1));
          }
        }
      }

      // trim off the trailing comma
      idBuffer.deleteCharAt(idBuffer.length() - 1);

      // now do the replacement
      // append to the buffer the matched sequence, substituting out group(1) with the updated ids
      matcher.appendReplacement(
          buffer,
          matcher.group().substring(0, matcher.start(1) - matcher.start())
              + idBuffer.toString()
              + "\"");
    }

    // append the rest of htmlform
    matcher.appendTail(buffer);

    formXmlData = buffer.toString();

    // now recursively handle any keys we have discovered during this substitution
    for (String key : keysToReplace) {
      formXmlData = replaceIdsWithUuidsHelper(formXmlData, key);
    }

    return formXmlData;
  }
  /**
   * Construct a new EncounterDetailSubmissionElement
   *
   * @param context
   * @param parameters
   * @should display 'Enter' option if 'type' is set to Autocomplete
   */
  public EncounterDetailSubmissionElement(
      FormEntryContext context, Map<String, Object> parameters) {

    // Register Date and Time widgets, if appropriate
    if (Boolean.TRUE.equals(parameters.get("date"))) {

      dateWidget = new DateWidget();
      dateErrorWidget = new ErrorWidget();

      if (context.getExistingEncounter() != null) {
        dateWidget.setInitialValue(context.getExistingEncounter().getEncounterDatetime());
      } else if (parameters.get("defaultDate") != null) {
        dateWidget.setInitialValue(parameters.get("defaultDate"));
      }

      if (parameters.get("disallowMultipleEncountersOnDate") != null
          && StringUtils.hasText((String) parameters.get("disallowMultipleEncountersOnDate"))) {
        dateWidget.setOnChangeFunction(
            "existingEncounterOnDate(this, '"
                + parameters.get("disallowMultipleEncountersOnDate")
                + "') ");
      }

      if ("true".equals(parameters.get("showTime"))) {
        timeWidget = new TimeWidget();
        timeErrorWidget = new ErrorWidget();
        if (context.getExistingEncounter() != null) {
          timeWidget.setInitialValue(context.getExistingEncounter().getEncounterDatetime());
        } else if (parameters.get("defaultDate") != null) {
          timeWidget.setInitialValue(parameters.get("defaultDate"));
        }
        context.registerWidget(timeWidget);
        context.registerErrorWidget(timeWidget, timeErrorWidget);
      }
      context.registerWidget(dateWidget);
      context.registerErrorWidget(dateWidget, dateErrorWidget);
    }

    // Register Provider widgets, if appropriate
    if (Boolean.TRUE.equals(parameters.get("provider"))) {

      if ("autocomplete".equals(parameters.get("type"))) {
        providerWidget = new AutocompleteWidget(Person.class);
      } else {
        providerWidget = new DropdownWidget();
      }
      providerErrorWidget = new ErrorWidget();

      List<Option> providerOptions = new ArrayList<Option>();
      // If specific persons are specified, display only those persons in order
      String personsParam = (String) parameters.get("persons");
      if (personsParam != null) {
        for (String s : personsParam.split(",")) {
          Person p = HtmlFormEntryUtil.getPerson(s);
          if (p == null) {
            throw new RuntimeException("Cannot find Person: " + s);
          }
          String label = p.getPersonName().getFullName();
          providerOptions.add(new Option(label, p.getId().toString(), false));
        }
        removeNonProviders(providerOptions);
      }

      // Only if specific person ids are not passed in do we get by user Role
      if (providerOptions.isEmpty()) {

        List<PersonStub> users = new ArrayList<PersonStub>();
        List<Option> providerUsers = new ArrayList<Option>();

        // If the "role" attribute is passed in, limit to users with this role
        if (parameters.get("role") != null) {
          Role role = Context.getUserService().getRole((String) parameters.get("role"));
          if (role == null) {
            throw new RuntimeException("Cannot find role: " + parameters.get("role"));
          } else {
            users =
                Context.getService(HtmlFormEntryService.class)
                    .getUsersAsPersonStubs(role.getRole());
          }
        }

        // Otherwise, use default options appropriate to the underlying OpenMRS version
        else {
          if (openmrsVersionDoesNotSupportProviders()) {
            // limit to users with the default OpenMRS PROVIDER role,
            String defaultRole = OpenmrsConstants.PROVIDER_ROLE;
            Role role = Context.getUserService().getRole(defaultRole);
            if (role != null) {
              users =
                  Context.getService(HtmlFormEntryService.class)
                      .getUsersAsPersonStubs(role.getRole());
            }
            // If this role isn't used, default to all Users
            if (users.isEmpty()) {
              users = Context.getService(HtmlFormEntryService.class).getUsersAsPersonStubs(null);
            }
          } else {
            // in OpenMRS 1.9+, get all suitable providers
            users = getAllProvidersThatArePersonsAsPersonStubs();
          }
        }

        for (PersonStub personStub : users) {

          Option option = new Option(personStub.toString(), personStub.getId().toString(), false);
          providerUsers.add(option);
        }
        providerOptions.addAll(providerUsers);
      }

      // Set default values as appropriate
      Person defaultProvider = null;
      Option defProviderOption;
      if (context.getExistingEncounter() != null) {
        defaultProvider = context.getExistingEncounter().getProvider();
        // this is done to avoid default provider being added twice due to that it can be added from
        // the
        // users = getAllProvidersThatArePersonsAsPersonStubs(); section with selected="false",
        // therefore this can't be caught when
        // searching whether the options list contains the 'defaultProvider'
        boolean defaultOptionPresent = false;
        if (defaultProvider != null) {
          for (Option option : providerOptions) {
            if (option.getValue().equals(defaultProvider.getId().toString())) {
              defaultOptionPresent = true;
              providerOptions.remove(option);
              break;
            }
          }
        }
        if (defaultOptionPresent) {
          defProviderOption =
              new Option(
                  defaultProvider.getPersonName().getFullName(),
                  defaultProvider.getId().toString(),
                  true);
          providerOptions.add(defProviderOption);
        }

      } else {
        String defParam = (String) parameters.get("default");
        if (StringUtils.hasText(defParam)) {
          if ("currentuser".equalsIgnoreCase(defParam)) {
            defaultProvider = Context.getAuthenticatedUser().getPerson();
          } else {
            defaultProvider = HtmlFormEntryUtil.getPerson(defParam);
          }
          if (defaultProvider == null) {
            throw new IllegalArgumentException(
                "Invalid default provider specified for encounter: " + defParam);
          } else {
            defProviderOption =
                new Option(
                    defaultProvider.getPersonName().getFullName(),
                    defaultProvider.getId().toString(),
                    true);
            for (Option option : providerOptions) {
              if (option.getValue().equals(defProviderOption.getValue())) {
                providerOptions.remove(option);
                break;
              }
            }
            providerOptions.add(defProviderOption);
          }
        }
      }
      if (defaultProvider != null) {
        providerWidget.setInitialValue(new PersonStub(defaultProvider));
      }
      Collections.sort(providerOptions, new OptionComparator());

      if (("autocomplete").equals(parameters.get("type"))) {
        providerWidget.addOption(new Option());
        if (!providerOptions.isEmpty()) {
          providerWidget.setOptions(providerOptions);
        }

      } else {
        // if initialValueIsSet=false, no initial/default provider, hence this shows the 'select
        // input' field as first option
        boolean initialValueIsSet = !(providerWidget.getInitialValue() == null);
        providerWidget.addOption(
            new Option(
                Context.getMessageSourceService().getMessage("htmlformentry.chooseAProvider"),
                "",
                !initialValueIsSet)); // if no initial or default value

        if (!providerOptions.isEmpty()) {
          for (Option option : providerOptions) {
            providerWidget.addOption(option);
          }
        }
      }
      context.registerWidget(providerWidget);
      context.registerErrorWidget(providerWidget, providerErrorWidget);
    }

    if (Boolean.TRUE.equals(parameters.get("encounterType"))) {
      encounterTypeWidget = new EncounterTypeWidget();
      encounterTypeErrorWidget = new ErrorWidget();
      if (parameters.get("types") != null) {
        List<EncounterType> encounterTypes = new ArrayList<EncounterType>();
        String[] temp = ((String) parameters.get("types")).split(",");
        for (String s : temp) {
          EncounterType type = HtmlFormEntryUtil.getEncounterType(s);
          if (type == null) {
            throw new RuntimeException("Cannot find encounter type: " + s);
          }
          encounterTypes.add(type);
        }

        encounterTypeWidget.setOptions(encounterTypes);
      }
      // Set default values

      EncounterType defaultEncounterType = null;
      if (context.getExistingEncounter() != null) {
        defaultEncounterType = context.getExistingEncounter().getEncounterType();
      } else {
        String defaultTypeId = (String) parameters.get("default");
        if (StringUtils.hasText(defaultTypeId)) {
          defaultEncounterType = HtmlFormEntryUtil.getEncounterType(defaultTypeId);
        }
      }

      encounterTypeWidget.setInitialValue(defaultEncounterType);
      context.registerWidget(encounterTypeWidget);
      context.registerErrorWidget(encounterTypeWidget, encounterTypeErrorWidget);
    }

    // Register Location widgets, if appropriate
    if (Boolean.TRUE.equals(parameters.get("location"))) {

      locationErrorWidget = new ErrorWidget();
      List<Location> locations = new ArrayList<Location>();
      List<Option> locationOptions = new ArrayList<Option>();

      if ("autocomplete".equals(parameters.get("type"))) {
        locationWidget = new AutocompleteWidget(Location.class);
      } else {
        locationWidget = new DropdownWidget();
      }

      // If the "order" attribute is passed in, limit to the specified locations in order
      if (parameters.get("order") != null) {

        String[] temp = ((String) parameters.get("order")).split(",");
        for (String s : temp) {
          Location loc = HtmlFormEntryUtil.getLocation(s);
          if (loc == null) {
            throw new RuntimeException("Cannot find location: " + loc);
          }
          locations.add(loc);
        }
      }

      // Set default values
      Location defaultLocation = null;
      if (context.getExistingEncounter() != null) {
        defaultLocation = context.getExistingEncounter().getLocation();
      } else {
        String defaultLocId = (String) parameters.get("default");
        if (StringUtils.hasText(defaultLocId)) {
          defaultLocation = HtmlFormEntryUtil.getLocation(defaultLocId);
        }
      }
      defaultLocation = defaultLocation == null ? context.getDefaultLocation() : defaultLocation;
      locationWidget.setInitialValue(defaultLocation);

      if (!locations.isEmpty()) {
        for (Location location : locations) {
          String label = location.getName();
          Option option =
              new Option(label, location.getId().toString(), location.equals(defaultLocation));
          locationOptions.add(option);
        }
      } else {
        locations = Context.getLocationService().getAllLocations();
        for (Location location : locations) {
          String label = location.getName();
          Option option =
              new Option(label, location.getId().toString(), location.equals(defaultLocation));
          locationOptions.add(option);
        }
        Collections.sort(locationOptions, new OptionComparator());
      }

      if ("autocomplete".equals(parameters.get("type"))) {
        locationWidget.addOption(new Option());
        if (!locationOptions.isEmpty()) {
          locationWidget.setOptions(locationOptions);
        }
      } else {
        boolean initialValueIsSet = !(locationWidget.getInitialValue() == null);
        locationWidget.addOption(
            new Option(
                Context.getMessageSourceService().getMessage("htmlformentry.chooseALocation"),
                "",
                !initialValueIsSet));
        if (!locationOptions.isEmpty()) {
          for (Option option : locationOptions) locationWidget.addOption(option);
        }
      }
      context.registerWidget(locationWidget);
      context.registerErrorWidget(locationWidget, locationErrorWidget);
    }

    if (Boolean.TRUE.equals(parameters.get("showVoidEncounter"))
        && context.getMode()
            == Mode
                .EDIT) { // only show void option if the encounter already exists.  And VIEW implies
                         // not voided.
      if (parameters.get("toggle") != null) {
        ToggleWidget toggleWidget = new ToggleWidget((String) parameters.get("toggle"));
        voidWidget =
            new CheckboxWidget(
                " " + Context.getMessageSourceService().getMessage("general.voided"),
                (context.getExistingEncounter() != null
                        && context.getExistingEncounter().isVoided().equals(true))
                    ? "true"
                    : "false",
                toggleWidget.getTargetId(),
                toggleWidget.isToggleDim());
      } else {
        voidWidget = new CheckboxWidget();
      }
      voidWidget.setLabel(" " + Context.getMessageSourceService().getMessage("general.voided"));
      voidErrorWidget = new ErrorWidget();
      if (context.getExistingEncounter() != null
          && context.getExistingEncounter().isVoided().equals(true))
        voidWidget.setInitialValue("true");
      context.registerWidget(voidWidget);
      context.registerErrorWidget(voidWidget, voidErrorWidget);
    }

    // set the id, if it has been specified
    if (parameters.get("id") != null) {
      id = (String) parameters.get("id");
    }
  }