/**
* gets patients pediatrics who have adult who stage
*
* @param session
* @return patientsPediatricsWhoHaveAdultWhoStage
*/
public List<Patient> getPatientsPediatricsWhoHaveAdultWhoStage() {
List<Patient> patientsInHIVProgram = new ArrayList<Patient>();
List<Patient> patientsPediatricsInHIVProgram = new ArrayList<Patient>();
List<Patient> patientsPediatricsWhoHaveAdultWhoStage = new ArrayList<Patient>();
List<Patient> patientsWhoHaveAdultWhoStage = new ArrayList<Patient>();
// List<Person> persons = new ArrayList<Person>();
// List<Obs> observers = new ArrayList<Obs>();
ProgramWorkflowService programService = Context.getProgramWorkflowService();
Program program = programService.getProgram(2);
patientsInHIVProgram = getPatientsCurrentlyInHIVProgram(program);
for (Patient patient : patientsInHIVProgram) {
if (patient.getAge() < 15) {
patientsPediatricsInHIVProgram.add(patient);
}
}
DataQualityService dqs = ((DataQualityService) Context.getService(DataQualityService.class));
List<Integer> patientIds = dqs.getPatientsWhoHaveAdultWhoStage();
for (Integer patientId : patientIds) {
patientsWhoHaveAdultWhoStage.add(getPatientById(patientId));
}
for (Patient patient : patientsWhoHaveAdultWhoStage) {
if (patientsPediatricsInHIVProgram.contains(patient)) {
patientsPediatricsWhoHaveAdultWhoStage.add(patient);
}
}
return patientsPediatricsWhoHaveAdultWhoStage;
}
@Test
@Verifies(
value = "should return program enrollment after specified date",
method = "getClosestFutureProgramEnrollment(Patient,Program,Date)")
public void shouldReturnPatientProgramWithEnrollmentAfterSpecifiedDate() throws Exception {
// load this data set so that we get the additional patient program created in this data case
executeDataSet(
XML_DATASET_PATH + new TestUtil().getTestDatasetFilename(XML_REGRESSION_TEST_DATASET));
ProgramWorkflowService pws = Context.getProgramWorkflowService();
Patient patient = Context.getPatientService().getPatient(2);
Program program = pws.getProgram(1);
Calendar cal = Calendar.getInstance();
cal.set(2001, 6, 31);
Date date = cal.getTime();
PatientProgram pp = HtmlFormEntryUtil.getClosestFutureProgramEnrollment(patient, program, date);
Assert.assertEquals("32296060-03aa-102d-b0e3-001ec94a0cc5", pp.getUuid());
// now, if we roll the date back a year earlier, it should get the earlier of the two programs
// for this patient
cal.set(2000, 6, 31);
date = cal.getTime();
pp = HtmlFormEntryUtil.getClosestFutureProgramEnrollment(patient, program, date);
Assert.assertEquals("32596060-03aa-102d-b0e3-001ec94a0cc5", pp.getUuid());
}
@Test
@Verifies(
value = "should return a list consisting of active, not retired, states",
method = "getPossibleNextStates")
public void getPossibleNextStates_shouldReturnNonRetiredStates() throws Exception {
executeDataSet(PROGRAM_NEXT_STATES_XML);
Integer patient = 11;
Integer workflow = 501;
Vector<ListItem> possibleNextStates;
/* retire a workflow state */
PatientProgram pp = Context.getProgramWorkflowService().getPatientProgram(patient);
ProgramWorkflow pw = pp.getProgram().getWorkflow(workflow);
Set<ProgramWorkflowState> pwss = pw.getStates();
for (ProgramWorkflowState pws : pwss) {
Concept cp = pws.getConcept();
ConceptName cn = cp.getName();
if (cn != null) {
String cnn = cn.getName();
if (cnn.equalsIgnoreCase("Test State 3")) {
pws.setRetired(true);
}
}
}
possibleNextStates = dwrProgramWorkflowService.getPossibleNextStates(patient, workflow);
assertFalse(possibleNextStates.isEmpty());
assertEquals(2, possibleNextStates.size());
}
public void controller(
FragmentModel model,
@FragmentParam("patient") Patient patient,
@FragmentParam("program") Program program,
@FragmentParam(required = false, value = "registrationFormUuid") String regFormUuid,
@FragmentParam(required = false, value = "exitFormUuid") String exitFormUuid) {
ProgramWorkflowService pws = Context.getProgramWorkflowService();
PatientProgram currentEnrollment = null;
List<PatientProgram> pastEnrollments = new ArrayList<PatientProgram>();
for (PatientProgram pp :
pws.getPatientPrograms(patient, program, null, null, null, null, false)) {
if (pp.getActive()) {
currentEnrollment = pp;
} else {
pastEnrollments.add(pp);
}
}
model.addAttribute("patient", patient);
model.addAttribute("program", program);
model.addAttribute("registrationFormUuid", regFormUuid);
model.addAttribute("exitFormUuid", exitFormUuid);
model.addAttribute("currentEnrollment", currentEnrollment);
model.addAttribute("pastEnrollments", pastEnrollments);
}
/**
* Gets the specified program
*
* @param uuid the uuid
* @return the program
*/
public static Program getProgram(String uuid) {
Program ret = Context.getProgramWorkflowService().getProgramByUuid(uuid);
if (ret == null) {
throw new IllegalArgumentException("No such program with identifier " + uuid);
}
return ret;
}
/** @see {@link HtmlFormEntryUtil#isEnrolledInProgram(Patient,Program,Date)} */
@Test
@Verifies(
value = "should return false if the patient is not enrolled in the program",
method = "isEnrolledInProgram(Patient,Program,Date)")
public void isEnrolledInProgram_shouldReturnFalseIfThePatientIsNotEnrolledInTheProgram()
throws Exception {
Patient patient = Context.getPatientService().getPatient(6);
Program program = Context.getProgramWorkflowService().getProgram(1);
Assert.assertFalse(HtmlFormEntryUtil.isEnrolledInProgramOnDate(patient, program, new Date()));
}
/** @see {@link HtmlFormEntryUtil#getState(String,Program)} */
@Test
@Verifies(
value = "should return the state with the matching id",
method = "getState(String,Program)")
public void getStateProgram_shouldReturnTheStateWithTheMatchingId() throws Exception {
Assert.assertEquals(
"92584cdc-6a20-4c84-a659-e035e45d36b0",
HtmlFormEntryUtil.getState("1", Context.getProgramWorkflowService().getProgram(1))
.getUuid());
}
/** @see {@link HtmlFormEntryUtil#isEnrolledInProgram(Patient,Program,Date)} */
@Test
@Verifies(
value = "should return true if the patient is enrolled in the program at the specified date",
method = "isEnrolledInProgram(Patient,Program,Date)")
public void
isEnrolledInProgram_shouldReturnTrueIfThePatientIsEnrolledInTheProgramAtTheSpecifiedDate()
throws Exception {
Patient patient = Context.getPatientService().getPatient(2);
Program program = Context.getProgramWorkflowService().getProgram(1);
Assert.assertTrue(HtmlFormEntryUtil.isEnrolledInProgramOnDate(patient, program, new Date()));
}
/**
* * Get the program by: 1)an integer id like 5090 or 2) uuid like
* "a3e12268-74bf-11df-9768-17cfc9833272"
*
* @param Id
* @return the program if exist, else null
* @should find a program by its id
* @should find a program by its uuid
* @should return null otherwise
*/
public static Program getProgram(String id) {
Program program = null;
if (id != null) {
try { // handle integer: id
int programId = Integer.parseInt(id);
program = Context.getProgramWorkflowService().getProgram(programId);
return program;
} catch (Exception ex) {
// do nothing
}
// handle uuid id: "a3e1302b-74bf-11df-9768-17cfc9833272", if id matches uuid pattern
if (Pattern.compile("\\w+-\\w+-\\w+-\\w+-\\w+").matcher(id).matches()) {
program = Context.getProgramWorkflowService().getProgramByUuid(id);
return program;
}
}
return program;
}
@Test
@Verifies(
value = "should return null if program enrollment date same as specified date",
method = "getClosestFutureProgramEnrollment(Patient,Program,Date)")
public void
getClosestFutureProgramEnrollment_shouldReturnNullIfProgramEnrollmentSameAsSpecifiedDate()
throws Exception {
ProgramWorkflowService pws = Context.getProgramWorkflowService();
Patient patient = Context.getPatientService().getPatient(2);
Program program = pws.getProgram(1);
Date date = pws.getPatientProgram(1).getDateEnrolled();
Assert.assertNull(HtmlFormEntryUtil.getClosestFutureProgramEnrollment(patient, program, date));
}
@Test
@Verifies(
value = "should return null if no program enrollment after specified date",
method = "getClosestFutureProgramEnrollment(Patient,Program,Date)")
public void
getClosestFutureProgramEnrollment_shouldReturnNullIfNoProgramEnrollmentAfterSpecifiedDate()
throws Exception {
ProgramWorkflowService pws = Context.getProgramWorkflowService();
Patient patient = Context.getPatientService().getPatient(2);
Program program = pws.getProgram(1);
Assert.assertNull(
HtmlFormEntryUtil.getClosestFutureProgramEnrollment(patient, program, new Date()));
}
/** @see {@link HtmlFormEntryUtil#getState(String,Program)} */
@Test
@Verifies(
value = "should look up a state by a concept mapping",
method = "getState(String,Program)")
public void getStateProgram_shouldLookUpAStateByAConceptMapping() throws Exception {
// load this data set so that we get the additional patient program with concept mapping
executeDataSet(
XML_DATASET_PATH + new TestUtil().getTestDatasetFilename(XML_REGRESSION_TEST_DATASET));
Assert.assertEquals(
"6de7ed10-53ad-11e1-8cb6-00248140a5eb",
HtmlFormEntryUtil.getState(
"SNOMED CT: Test Code", Context.getProgramWorkflowService().getProgram(10))
.getUuid());
}
/**
* Takes a "program_id:list" where program_id is the id of the program that this collection is for
* (or not present, if it's a new program) and list is a space-separated list of concept ids. This
* class is a bit of a hack, because I don't know a better way to do this. -DJ The purpose is to
* retire and un-retire workflows where possible rather than deleting and creating them.
*/
public void setAsText(String text) throws IllegalArgumentException {
if (StringUtils.hasText(text)) {
ConceptService cs = Context.getConceptService();
ProgramWorkflowService pws = Context.getProgramWorkflowService();
try {
int ind = text.indexOf(":");
String progIdStr = text.substring(0, ind);
text = text.substring(ind + 1);
if (program == null)
// if a program wasn't passed in, try to look it up now
program = pws.getProgram(Integer.valueOf(progIdStr));
} catch (Exception ex) {
}
String[] conceptIds = text.split(" ");
Set<ProgramWorkflow> oldSet =
program == null ? new HashSet<ProgramWorkflow>() : program.getAllWorkflows();
Set<Integer> newConceptIds = new HashSet<Integer>();
for (String id : conceptIds) {
if (id.trim().length() == 0) continue;
log.debug("trying " + id);
newConceptIds.add(Integer.valueOf(id.trim()));
}
// go through oldSet and see what we need to keep and what we need to unvoid
Set<Integer> alreadyDone = new HashSet<Integer>();
for (ProgramWorkflow pw : oldSet) {
if (!newConceptIds.contains(pw.getConcept().getConceptId())) {
pw.setRetired(true);
} else if (pw.isRetired()) { // && newConceptIds.contains(pw...)
pw.setRetired(false);
}
alreadyDone.add(pw.getConcept().getConceptId());
}
// now add any new ones
newConceptIds.removeAll(alreadyDone);
for (Integer conceptId : newConceptIds) {
ProgramWorkflow pw = new ProgramWorkflow();
pw.setProgram(program);
pw.setConcept(cs.getConcept(conceptId));
oldSet.add(pw);
}
setValue(oldSet);
} else {
setValue(null);
}
}
/** @see {@link HtmlFormEntryUtil#getState(String,Program)} */
@SuppressWarnings("deprecation")
@Test
@Verifies(
value = "should return the state with the matching uuid",
method = "getState(String,ProgramWorkflow)")
public void getStateWorkflow_shouldReturnTheStateWithTheMatchingUuid() throws Exception {
Assert.assertEquals(
"1",
HtmlFormEntryUtil.getState(
"92584cdc-6a20-4c84-a659-e035e45d36b0",
Context.getProgramWorkflowService().getWorkflow(1))
.getId()
.toString());
}
private void setupMappings() {
MetadataSource metadataSource = new MetadataSource();
metadataSource.setName("source");
metadataSource.setDateCreated(new Date());
metadataSource.setRetired(false);
metadataSource.setId(1);
metadataSource =
Context.getService(MetadataMappingService.class).saveMetadataSource(metadataSource);
MetadataTermMapping metadataTermMapping1 =
new MetadataTermMapping(
metadataSource, "DataClerk", Context.getUserService().getRole("Data Clerk"));
metadataTermMapping1.setName("mapping1");
Context.getService(MetadataMappingService.class).saveMetadataTermMapping(metadataTermMapping1);
MetadataTermMapping metadataTermMapping2 =
new MetadataTermMapping(
metadataSource, "ROLE", Context.getUserService().getRole("Provider"));
metadataTermMapping2.setName("mapping2");
Context.getService(MetadataMappingService.class).saveMetadataTermMapping(metadataTermMapping2);
MetadataTermMapping metadataTermMapping3 =
new MetadataTermMapping(
metadataSource,
"Location",
Context.getLocationService().getLocationByUuid("9356400c-a5a2-4532-8f2b-2361b3446eb8"));
metadataTermMapping3.setName("mapping3");
Context.getService(MetadataMappingService.class).saveMetadataTermMapping(metadataTermMapping3);
MetadataTermMapping metadataTermMapping4 =
new MetadataTermMapping(
metadataSource,
"MDR-TB PROGRAM",
Context.getProgramWorkflowService().getProgramByName("MDR-TB PROGRAM"));
metadataTermMapping4.setName("mapping4");
Context.getService(MetadataMappingService.class).saveMetadataTermMapping(metadataTermMapping4);
MetadataTermMapping metadataTermMapping5 =
new MetadataTermMapping(
metadataSource, "1", Context.getPatientService().getPatientIdentifierType(1));
metadataTermMapping5.setName("mapping5");
Context.getService(MetadataMappingService.class).saveMetadataTermMapping(metadataTermMapping5);
Context.flushSession();
}
/** @see {@link HtmlFormEntryUtil#isEnrolledInProgram(Patient,Program,Date)} */
@Test
@Verifies(
value = "should return false if the program was completed",
method = "isEnrolledInProgram(Patient,Program,Date)")
public void isEnrolledInProgram_shouldReturnFalseIfTheProgramWasCompleted() throws Exception {
ProgramWorkflowService pws = Context.getProgramWorkflowService();
Patient patient = Context.getPatientService().getPatient(2);
// for test purposes, lets set a program as complete
PatientProgram pp = pws.getPatientProgram(1);
Assert.assertSame(patient, pp.getPatient());
pp.setDateCompleted(new Date());
Thread.sleep(100);
pws.savePatientProgram(pp);
Assert.assertFalse(
HtmlFormEntryUtil.isEnrolledInProgramOnDate(patient, pws.getProgram(1), new Date()));
}
/**
* gets patients who are in PMTCT program with no CPN ID
*
* @param session
* @return
*/
public List<Patient> getPatientsWhoAreInPMTCTWithNoCPNId() {
List<Patient> patientsInPMTCTProgram = new ArrayList<Patient>();
List<Patient> patientsWithNoCPN = new ArrayList<Patient>();
List<Patient> patientsInPMTCTWithNoCPNId = new ArrayList<Patient>();
ProgramWorkflowService programService = Context.getProgramWorkflowService();
Program program = programService.getProgram(1);
patientsInPMTCTProgram = getPatientsCurrentlyInHIVProgram(program);
patientsWithNoCPN =
getPatientWithNoGivenAttribute(getGlobalProperty("patientIdentifierType.CPNID"));
for (Patient patient : patientsInPMTCTProgram) {
if (patientsWithNoCPN.contains(patient)) {
patientsInPMTCTWithNoCPNId.add(patient);
}
}
return patientsInPMTCTWithNoCPNId;
}
/** @see {@link HtmlFormEntryUtil#isEnrolledInProgram(Patient,Program,Date)} */
@Test
@Verifies(
value =
"should return false if the date is before the existing patient program enrollment date",
method = "isEnrolledInProgram(Patient,Program,Date)")
public void
isEnrolledInProgram_shouldReturnFalseIfTheDateIsBeforeTheExistingPatientProgramEnrollmentDateIgnoringTimeFields()
throws Exception { // 2008-08-01 00:00:00.0
ProgramWorkflowService pws = Context.getProgramWorkflowService();
Patient patient = Context.getPatientService().getPatient(2);
Program program = pws.getProgram(1);
PatientProgram pp = pws.getPatientProgram(1);
Calendar cal = Calendar.getInstance();
cal.set(2008, 6, 31);
Date newEnrollmentDate = cal.getTime();
Assert.assertTrue(newEnrollmentDate.before(pp.getDateEnrolled())); // sanity check
Assert.assertFalse(
HtmlFormEntryUtil.isEnrolledInProgramOnDate(patient, program, newEnrollmentDate));
}
@Test
public void shouldRespectClassesNotToExportGlobalProperty() throws Exception {
// include this set so that we get the mapping concept
executeDataSet(
XML_DATASET_PATH + new TestUtil().getTestDatasetFilename(XML_HTML_FORM_ENTRY_TEST_DATASET));
Context.getAdministrationService()
.saveGlobalProperty(
new GlobalProperty(
HtmlFormEntryConstants.GP_CLASSES_NOT_TO_EXPORT_WITH_MDS, "org.openmrs.Program"));
HtmlForm form = new HtmlForm();
form.setXmlData(
new TestUtil().loadXmlFromFile(XML_DATASET_PATH + "metadataSharingTestForm.xml"));
HtmlFormExporter exporter = new HtmlFormExporter(form);
HtmlForm formClone = exporter.export(true, true, true, true);
Collection<OpenmrsObject> dependencies = formClone.getDependencies();
// make sure all the appropriate concepts have been added to the dependencies
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-03aa-102d-b0e3-001ec94a0cc1")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-03aa-102d-b0e3-001ec94a0cc4")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-03aa-102d-b0e3-001ec94a0cc5")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-03aa-102d-b0e3-001ec94a0cc6")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-03aa-102d-b0e3-001ec94a0cc3")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("aa52296060-03-102d-b0e3-001ec94a0cc1")));
// this is the mapped concept XYZ:HT found in HtmlFormEntryTest-data
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("44d3611a-6699-4d52-823f-b4b788bac3e3")));
// drug discontinue reason, corresponds to concept 555 in regressionTest-data
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-0370-102d-b0e3-123456789011")));
// make sure the programs have NOT been added to the dependencies
Assert.assertFalse(
dependencies.contains(
Context.getProgramWorkflowService()
.getProgramByUuid("da4a0391-ba62-4fad-ad66-1e3722d16380")));
Assert.assertFalse(
dependencies.contains(
Context.getProgramWorkflowService()
.getProgramByUuid("71779c39-d289-4dfe-91b5-e7cfaa27c78b")));
// make sure the program workflows have been added to the dependencies
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getWorkflowByUuid("72a90efc-5140-11e1-a3e3-00248140a5eb")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getWorkflowByUuid("7c3e071a-53a7-11e1-8cb6-00248140a5eb")));
// make sure the program workflow states have been added to the dependencies
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getStateByUuid("92584cdc-6a20-4c84-a659-e035e45d36b0")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getStateByUuid("e938129e-248a-482a-acea-f85127251472")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getStateByUuid("860b3a13-d4b1-4f0a-b526-278652fa1809")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getStateByUuid("8ef66ca8-5140-11e1-a3e3-00248140a5eb")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getStateByUuid("67337cdc-53ad-11e1-8cb6-00248140a5eb")));
// make sure the drugs have been added to the dependencies
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getDrugByUuid("3cfcf118-931c-46f7-8ff6-7b876f0d4202")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getDrugByUuid("05ec820a-d297-44e3-be6e-698531d9dd3f")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getDrugByUuid("7e2323fa-0fa0-461f-9b59-6765997d849e")));
// make sure the locations have been added to the dependencies
Assert.assertTrue(
dependencies.contains(Context.getLocationService().getLocation("Never Never Land")));
Assert.assertTrue(
dependencies.contains(
Context.getLocationService()
.getLocationByUuid("9356400c-a5a2-4532-8f2b-2361b3446eb8")));
Assert.assertTrue(dependencies.contains(Context.getLocationService().getLocation(1)));
// make sure the provider has been added to the list of dependencies
Assert.assertTrue(
dependencies.contains(
Context.getPersonService().getPersonByUuid("c04ee3c8-b68f-43cc-bff3-5a831ee7225f")));
// make sure the patient identifier types have been added to the list of dependencies
Assert.assertTrue(
dependencies.contains(
Context.getPatientService()
.getPatientIdentifierTypeByUuid("1a339fe9-38bc-4ab3-b180-320988c0b968")));
Assert.assertTrue(
dependencies.contains(
Context.getPatientService()
.getPatientIdentifierTypeByUuid("2f470aa8-1d73-43b7-81b5-01f0c0dfa53c")));
// make sure the roles have been added to the list of dependencies
Assert.assertTrue(
dependencies.contains(
Context.getUserService().getRoleByUuid("92b70b00-58b1-11e0-80e3-0800200c9a66")));
Assert.assertTrue(
dependencies.contains(
Context.getUserService().getRoleByUuid("a238c500-58b1-11e0-80e3-0800200c9a66")));
}
@Test
@Verifies(
value = "should create cloned form to export with appropriate dependencies",
method = "createCloneForExport(HtmlForm)")
public void createCloneForExport_shouldCreateCloneWithDependencies() throws Exception {
// include this set so that we get the mapping concept
executeDataSet(
XML_DATASET_PATH + new TestUtil().getTestDatasetFilename(XML_HTML_FORM_ENTRY_TEST_DATASET));
HtmlForm form = new HtmlForm();
form.setXmlData(
new TestUtil().loadXmlFromFile(XML_DATASET_PATH + "metadataSharingTestForm.xml"));
HtmlFormExporter exporter = new HtmlFormExporter(form);
HtmlForm formClone = exporter.export(true, true, true, true);
Collection<OpenmrsObject> dependencies = formClone.getDependencies();
// make sure all the appropriate concepts have been added to the dependencies
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-03aa-102d-b0e3-001ec94a0cc1")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-03aa-102d-b0e3-001ec94a0cc4")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-03aa-102d-b0e3-001ec94a0cc5")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-03aa-102d-b0e3-001ec94a0cc6")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-03aa-102d-b0e3-001ec94a0cc3")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("aa52296060-03-102d-b0e3-001ec94a0cc1")));
// this is the mapped concept XYZ:HT found in HtmlFormEntryTest-data
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("44d3611a-6699-4d52-823f-b4b788bac3e3")));
// drug discontinue reason, corresponds to concept 555 in regressionTest-data
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getConceptByUuid("32296060-0370-102d-b0e3-123456789011")));
// make sure the programs have been added to the dependencies
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getProgramByUuid("da4a0391-ba62-4fad-ad66-1e3722d16380")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getProgramByUuid("71779c39-d289-4dfe-91b5-e7cfaa27c78b")));
// make sure the program workflows have been added to the dependencies
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getWorkflowByUuid("72a90efc-5140-11e1-a3e3-00248140a5eb")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getWorkflowByUuid("7c3e071a-53a7-11e1-8cb6-00248140a5eb")));
// make sure the program workflow states have been added to the dependencies
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getStateByUuid("92584cdc-6a20-4c84-a659-e035e45d36b0")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getStateByUuid("e938129e-248a-482a-acea-f85127251472")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getStateByUuid("860b3a13-d4b1-4f0a-b526-278652fa1809")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getStateByUuid("8ef66ca8-5140-11e1-a3e3-00248140a5eb")));
Assert.assertTrue(
dependencies.contains(
Context.getProgramWorkflowService()
.getStateByUuid("67337cdc-53ad-11e1-8cb6-00248140a5eb")));
// note this this assertion fails--currently, the exporter WILL NOT be able to pick up states
// referenced concept map
// (this is because the exporter considers each attribute separately, and to you can't get a
// state referenced by concept map without knowing the corresponding program or workflow)
// however, this should not be a problem because the state should be included by MDS when it's
// parent program or workflow is exported
// Assert.assertTrue(dependencies.contains(Context.getProgramWorkflowService().getStateByUuid(
// "6de7ed10-53ad-11e1-8cb6-00248140a5eb")));
// make sure the drugs have been added to the dependencies
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getDrugByUuid("3cfcf118-931c-46f7-8ff6-7b876f0d4202")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getDrugByUuid("05ec820a-d297-44e3-be6e-698531d9dd3f")));
Assert.assertTrue(
dependencies.contains(
Context.getConceptService().getDrugByUuid("7e2323fa-0fa0-461f-9b59-6765997d849e")));
// make sure the locations have been added to the dependencies
Assert.assertTrue(
dependencies.contains(Context.getLocationService().getLocation("Never Never Land")));
Assert.assertTrue(
dependencies.contains(
Context.getLocationService()
.getLocationByUuid("9356400c-a5a2-4532-8f2b-2361b3446eb8")));
Assert.assertTrue(dependencies.contains(Context.getLocationService().getLocation(1)));
// make sure the provider has been added to the list of dependencies
Assert.assertTrue(
dependencies.contains(
Context.getPersonService().getPersonByUuid("c04ee3c8-b68f-43cc-bff3-5a831ee7225f")));
// make sure the patient identifier types have been added to the list of dependencies
Assert.assertTrue(
dependencies.contains(
Context.getPatientService()
.getPatientIdentifierTypeByUuid("1a339fe9-38bc-4ab3-b180-320988c0b968")));
Assert.assertTrue(
dependencies.contains(
Context.getPatientService()
.getPatientIdentifierTypeByUuid("2f470aa8-1d73-43b7-81b5-01f0c0dfa53c")));
// make sure the roles have been added to the list of dependencies
Assert.assertTrue(
dependencies.contains(
Context.getUserService().getRoleByUuid("92b70b00-58b1-11e0-80e3-0800200c9a66")));
Assert.assertTrue(
dependencies.contains(
Context.getUserService().getRoleByUuid("a238c500-58b1-11e0-80e3-0800200c9a66")));
// TODO test exporting location tags once we upgrade to only supporting OpenMRS 1.7 and above
// (since in 1.6, locations tags don't have names)
}
@Override
public String getOverrideContent(String str) {
if (!Context.isAuthenticated()) {
return "";
}
String gp =
Context.getAdministrationService()
.getGlobalProperty("htmlformflowsheet.patientChartFormIds");
if (StringUtils.isEmpty(gp)) {
return "";
}
StringBuilder sbExisting = new StringBuilder("");
StringBuilder sbNonExisting = new StringBuilder("");
try {
String patientId = this.getParameterMap().get("patientId");
Patient p = Context.getPatientService().getPatient(Integer.valueOf(patientId));
for (StringTokenizer st = new StringTokenizer(gp, ","); st.hasMoreTokens(); ) {
Map<Integer, Set<Integer>> progForms = new HashMap<Integer, Set<Integer>>();
Set<Integer> programIds = new HashSet<Integer>();
String formId = st.nextToken().trim();
if (formId.contains(":")) {
String[] formIdSplit = formId.split(":");
formId = formIdSplit[0];
// check for required programs:
String programInfo = formIdSplit[1];
if (programInfo.contains("|")) {
for (StringTokenizer strTok = new StringTokenizer(programInfo, "|");
strTok.hasMoreTokens(); ) {
String sTmp = strTok.nextToken().trim();
addFormToProgramList(progForms, Integer.valueOf(formId), Integer.valueOf(sTmp));
programIds.add(Integer.valueOf(sTmp));
}
} else {
// todo: support lookup programs by uuid and forms by uuid?
addFormToProgramList(progForms, Integer.valueOf(formId), Integer.valueOf(programInfo));
programIds.add(Integer.valueOf(programInfo));
}
}
Form form = HtmlFormFlowsheetUtil.getFormFromString(formId);
List<PatientProgram> pps =
Context.getProgramWorkflowService()
.getPatientPrograms(p, null, null, null, null, null, false);
List<Encounter> encs =
Context.getEncounterService()
.getEncounters(
p, null, null, null, Collections.singletonList(form), null, null, false);
// for (Map.Entry<Integer, Set<Integer>> m : progForms.entrySet()){
// System.out.println(m.getKey()+ ":" + m.getValue());
// }
// 1. no program association to form. always show.
if (progForms.get(Integer.valueOf(formId)) == null
|| progForms.get(Integer.valueOf(formId)).size() == 0) {
if (encs.size() == 0) {
// if no encs, show add new
sbNonExisting.append(
" | <a href=\"/"
+ WebConstants.WEBAPP_NAME
+ "/module/htmlformentry/htmlFormEntry.form?personId="
+ p.getPersonId()
+ "&patientId="
+ p.getPatientId()
+ "&returnUrl=&formId="
+ form.getFormId()
+ "\">"
+ form.getName()
+ "</a> | ");
} else {
// if encs, show existing flowsheet parent(s)
for (Encounter e : encs) {
sbExisting.append(
" | <a href=\"/"
+ WebConstants.WEBAPP_NAME
+ "/module/htmlformentry/htmlFormEntry.form?encounterId="
+ e.getEncounterId()
+ "&mode=EDIT\">"
+ form.getName()
+ " "
+ "("
+ Context.getDateFormat().format(e.getEncounterDatetime())
+ ")</a> | ");
}
}
} else {
// 2. program(s) specified for form
// this builds a map of encounter corresponding to the parent form creation to the
// patientProgram is was created in.
Map<Encounter, PatientProgram> encounterToPatientProgram =
new HashMap<Encounter, PatientProgram>();
for (Encounter e : encs) {
for (PatientProgram pp : pps) {
// if encounter is later than start date and less than end date or end date is null
if (programIds.contains(pp.getProgram().getProgramId())
&& e.getEncounterDatetime().getTime() >= pp.getDateEnrolled().getTime()
&& ((pp.getDateCompleted() == null
|| pp.getDateCompleted().getTime() >= e.getEncounterDatetime().getTime()))) {
// encounter is in patientprogram
encounterToPatientProgram.put(e, pp);
}
}
}
// show existing based on the map
for (Map.Entry<Encounter, PatientProgram> m : encounterToPatientProgram.entrySet()) {
sbExisting.append(
" | <a href=\"/"
+ WebConstants.WEBAPP_NAME
+ "/module/htmlformentry/htmlFormEntry.form?encounterId="
+ m.getKey().getEncounterId()
+ "&mode=EDIT\">"
+ form.getName());
if (m.getValue() != null) {
sbExisting.append(
" "
+ "("
+ Context.getDateFormat().format(m.getValue().getDateEnrolled())
+ " - ");
if (m.getValue().getDateCompleted() != null)
sbExisting.append(Context.getDateFormat().format(m.getValue().getDateCompleted()));
sbExisting.append(")");
}
sbExisting.append("</a> | ");
}
// show add new
// if patient is in program currently, AND patient doesn't have an encounter for this
// program
PatientProgram ppActive = activePatientProgram(pps, programIds);
boolean found = false;
if (ppActive != null) {
for (Map.Entry<Encounter, PatientProgram> m : encounterToPatientProgram.entrySet()) {
if (m.getValue() != null && m.getValue().equals(ppActive)) found = true;
}
if (!found)
sbNonExisting.append(
" | <a href=\"/"
+ WebConstants.WEBAPP_NAME
+ "/module/htmlformentry/htmlFormEntry.form?personId="
+ p.getPersonId()
+ "&patientId="
+ p.getPatientId()
+ "&returnUrl=&formId="
+ form.getFormId()
+ "\"> "
+ form.getName()
+ "</a> | ");
}
}
}
String retString = "<table><tr><td>";
if (!sbExisting.toString().equals(""))
retString += "Existing Patient Chart(s): " + sbExisting.toString();
retString += "</td></tr><tr><td>";
if (!sbNonExisting.toString().equals(""))
retString += "Create A New Patient Charts: " + sbNonExisting.toString();
retString += "</td></tr></table>";
return retString.replace("| |", " | ");
} catch (Exception ex) {
ex.printStackTrace();
return "";
}
}
/**
* gets patients by checking Type of abnormal datas
*
* @param programIdKey
* @param session
* @param valueRangeType
* @return
*/
public List<Patient> checkTypeController(String programIdKey, String valueRangeType)
throws Exception {
// log.info("@@@@@@@@@@@@@@@@@@@@@ programIdKey "+programIdKey);
List<Patient> patients = new ArrayList<Patient>();
List<Patient> activePatients = new ArrayList<Patient>();
List<Patient> patientsInHIVProgram = new ArrayList<Patient>();
if (programIdKey.equals("PatientsWithNoProgramsEnrollmentDates")) {
patients = getPatientsWithNoProgramsEnrollmentDates();
DataqualityFormController.setMsgToDisplay("Patients with no programs enrollment dates");
} else if (programIdKey.equals("PatientsDrugsWithDiscontinuedDateWithoutStartDate")) {
patients = getPatientsDrugsWithDiscontinuedDateWithoutStartDate();
DataqualityFormController.setMsgToDisplay(
"Patients Drugs with discontinued date without start date");
} else if (programIdKey.equals("DrugsWithDiscontinuedDateHigherThanDrugStartDate")) {
patients = getPatientsWithDiscontinuedDateHigherThanDrugStartDate();
DataqualityFormController.setMsgToDisplay("");
} else if (programIdKey.equals("DrugsWithoutStartDate")) {
patients = getPatientsWithoutStartDate();
DataqualityFormController.setMsgToDisplay("Patients with Drugs without start date");
} else if (programIdKey.equals("patientrsWithoutNames")) {
patients = getPatientsWithoutNames();
DataqualityFormController.setMsgToDisplay("Patientrs without names");
} else if (programIdKey.equals("patientInAnyHivProgramWithoutAdmitionMode")) {
// log.info("top patientInAnyHivProgramWithoutAdmitionMode");
patientsInHIVProgram = new ArrayList<Patient>();
List<Patient> patientsWithNoAdmitionMode = new ArrayList<Patient>();
// getting programs
ProgramWorkflowService programService = Context.getProgramWorkflowService();
Program hivProgram = programService.getProgram(getGlobalProperty("HIVProgramId"));
patientsInHIVProgram = getPatientsCurrentlyInHIVProgram(hivProgram);
patientsWithNoAdmitionMode =
getPatientWithoutAdmitionModeConcept(
getConcept(getGlobalProperty("concept.methodOfEnrollement")));
for (Patient patient : patientsWithNoAdmitionMode) {
if (patientsInHIVProgram.contains(patient)) {
patients.add(patient);
}
}
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.patientInAnyHivProgramWithoutAdmitionMode");
log.info("bottom patientInAnyHivProgramWithoutAdmitionMode");
} else if (programIdKey.equals("patientsWithoutProgram")) {
log.info("top patientsWithoutProgram");
patients = getPatientWithoutProgram();
DataqualityFormController.setMsgToDisplay("tracdataquality.indicator.patientsWithoutProgram");
log.info("bottom patientsWithoutProgram");
} else if (programIdKey.equals("patientsWithnoWeight")) {
log.info("top patientsWithnoWeight");
Concept concept = getConcept(getGlobalProperty("concept.weight"));
patients = getPatientWithoutAgivenConcept(concept);
DataqualityFormController.setMsgToDisplay("tracdataquality.indicator.patientsWithnoWeight");
log.info("bottom patientsWithnoWeight");
} else if (programIdKey.equals("patientsWithNoHeight")) {
log.info("top patientsWithNoHeight");
Concept concept = getConcept(getGlobalProperty("concept.height"));
patients = getPatientWithoutAgivenConcept(concept);
DataqualityFormController.setMsgToDisplay("tracdataquality.indicator.patientsWithNoHeight");
log.info("bottom patientsWithNoHeight");
} else if (programIdKey.equals("patientWithNoHIVViralLoad")) {
log.info("top patientWithNoHIVViralLoad");
List<Patient> patientsWithNoViralLoad = new ArrayList<Patient>();
Concept viralLoadConcept = getConcept(getGlobalProperty("concept.viralLoad"));
ProgramWorkflowService programService = Context.getProgramWorkflowService();
Program hivProgram = programService.getProgram(getGlobalProperty("HIVProgramId"));
patientsWithNoViralLoad = getPatientWithoutAgivenConcept(viralLoadConcept);
patientsInHIVProgram = getPatientsCurrentlyInHIVProgram(hivProgram);
for (Patient patient : patientsInHIVProgram) {
if (patientsWithNoViralLoad.contains(patient)) {
patients.add(patient);
}
}
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.patientWithNoHIVViralLoad");
log.info("bottom patientWithNoHIVViralLoad");
} else if (programIdKey.equals("patientWithHIVPositiveAndNoCD4")) {
log.info("top patientWithHIVPositiveAndNoCD4");
List<Patient> patientsWithNoCD4 = new ArrayList<Patient>();
patientsInHIVProgram = new ArrayList<Patient>();
Concept cd4 = getConcept(getGlobalProperty("concept.cd4_count"));
ProgramWorkflowService programService = Context.getProgramWorkflowService();
Program hivProgram = programService.getProgram(getGlobalProperty("HIVProgramId"));
patientsWithNoCD4 = getPatientWithoutAgivenConcept(cd4);
patientsInHIVProgram = getPatientsCurrentlyInHIVProgram(hivProgram);
for (Patient patient : patientsInHIVProgram) {
if (patientsWithNoCD4.contains(patient)) {
patients.add(patient);
}
}
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.patientWithHIVPositiveAndNoCD4");
log.info("bottom patientWithHIVPositiveAndNoCD4");
} else if (programIdKey.equals("patientWithNoWhoStage")) {
log.info("top patientWithNoWhoStage");
Concept concept = getConcept(getGlobalProperty("concept.whoStage"));
patients = getPatientWithoutAgivenConcept(concept);
DataqualityFormController.setMsgToDisplay("tracdataquality.indicator.patientWithNoWhoStage");
log.info("bottom patientWithNoWhoStage");
} else if (programIdKey.equals("patientWithMoreKgs")) {
log.info("top patientWithMoreKgs");
// log.info("!!!!!!!!!!!!!!!!!!!!!!!! am getting in if statment");
Concept concept = getConcept(getGlobalProperty("concept.weight"));
// log.info(" !!!@@@@###$$%%^^&&**(())__++++++++++++++++ "+concept);
double valueRange = Double.parseDouble(valueRangeType);
// log.info("!!!!!!!!!!!!!!!!!!!!!!! !!!@@@@###$$%%^^&&**(())__++++++++++++++++
// "+valueRange);
patients = getPatientsWithMoreValueOnConcept(concept, valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients with more than " + valueRange + " Weight");
log.info("bottom patientWithMoreKgs");
} else if (programIdKey.equals("patientsWithMoreHeight")) {
log.info("top patientsWithMoreHeight");
Concept concept = getConcept(getGlobalProperty("concept.height"));
double valueRange = Double.parseDouble(valueRangeType);
patients = getPatientsWithMoreValueOnConcept(concept, valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients with more than " + valueRange + " height");
log.info("bottom patientsWithMoreHeight");
} else if (programIdKey.equals("patientsWithMoreBMI")) {
log.info("top patientsWithMoreBMI");
Concept concept = getConcept(getGlobalProperty("concept.BMI"));
double valueRange = Double.parseDouble(valueRangeType);
patients = getPatientsWithMoreValueOnConcept(concept, valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients with more than " + valueRange + " BMI");
log.info("bottom patientsWithMoreBMI");
} else if (programIdKey.equals("patientsWithMoreBLOODOXYGENSATURATION")) {
log.info("top patientsWithMoreBLOODOXYGENSATURATION");
double valueRange = Double.parseDouble(valueRangeType);
patients =
getPatientsWithMoreValueOnConcept(
getConcept(getGlobalProperty("concept.bloodOxygenSaturation")), valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients with more than " + valueRange + " BLOODOXYGENSATURATION");
log.info("bottom patientsWithMoreBLOODOXYGENSATURATION");
} else if (programIdKey.equals("patientsWithMoreDIASTOLICBLOODPRESSURE")) {
log.info("top patientsWithMoreDIASTOLICBLOODPRESSURE");
double valueRange = Double.parseDouble(valueRangeType);
patients =
getPatientsWithMoreValueOnConcept(
getConcept(getGlobalProperty("concept.diastolicBloodPressure")), valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients with more than " + valueRange + " of DIASTOLICBLOODPRESSURE");
log.info("bottom patientsWithMoreDIASTOLICBLOODPRESSURE");
} else if (programIdKey.equals("patientsWithMoreHEADCIRCUMFERENCE")) {
log.info("top patientsWithMoreHEADCIRCUMFERENCE");
double valueRange = Double.parseDouble(valueRangeType);
patients =
getPatientsWithMoreValueOnConcept(
getConcept(getGlobalProperty("concept.headCircumference")), valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients with more than " + valueRange + " HEADCIRCUMFERENCE");
log.info("bottom patientsWithMoreHEADCIRCUMFERENCE");
} else if (programIdKey.equals("patientsWithMoreKARNOFSKYPERFORMANCESCORE")) {
log.info("top patientsWithMoreKARNOFSKYPERFORMANCESCORE");
double valueRange = Double.parseDouble(valueRangeType);
patients =
getPatientsWithMoreValueOnConcept(
getConcept(getGlobalProperty("concept.karnofskyPerformanceScore")), valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients with more than " + valueRange + " of KARNOFSKYPERFORMANCESCORE");
log.info("bottom patientsWithMoreKARNOFSKYPERFORMANCESCORE");
} else if (programIdKey.equals("patientsWithMorePULSE")) {
log.info("top patientsWithMorePULSE");
double valueRange = Double.parseDouble(valueRangeType);
patients =
getPatientsWithMoreValueOnConcept(
getConcept(getGlobalProperty("concept.pulse")), valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients with more than " + valueRange + " PULSE");
log.info("bottom patientsWithMorePULSE");
} else if (programIdKey.equals("patientsWithMoreRESPIRATORYRATE")) {
log.info("top patientsWithMoreRESPIRATORYRATE");
double valueRange = Double.parseDouble(valueRangeType);
patients =
getPatientsWithMoreValueOnConcept(
getConcept(getGlobalProperty("concept.respiratoryRate")), valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients with more than " + valueRange + " RESPIRATORYRATE");
log.info("bottom patientsWithMoreRESPIRATORYRATE");
} else if (programIdKey.equals("patientsWithMoreSYSTOLICBLOODPRESSURE")) {
log.info("top patientsWithMoreSYSTOLICBLOODPRESSURE");
double valueRange = Double.parseDouble(valueRangeType);
patients =
getPatientsWithMoreValueOnConcept(
getConcept(getGlobalProperty("concept.systolicBloodPressure")), valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients with more than " + valueRange + " SYSTOLICBLOODPRESSURE");
log.info("bottom patientsWithMoreSYSTOLICBLOODPRESSURE");
} else if (programIdKey.equals("patientsWithMoreTEMPERATURE")) {
log.info("top patientsWithMoreTEMPERATURE");
double valueRange = Double.parseDouble(valueRangeType);
patients =
getPatientsWithMoreValueOnConcept(
getConcept(getGlobalProperty("concept.temperature")), valueRange);
DataqualityFormController.setMsgToDisplay(
"Patients.With.More.Than" + valueRange + " TEMPERATURE");
log.info("bottom patientsWithMoreTEMPERATURE");
} else if (programIdKey.equals("patientWithNoContactInformation")) {
log.info("top patientWithNoContactInformation");
List<Patient> patientsWithoutPhoneNumber = new ArrayList<Patient>();
List<Patient> patientsWithoutAlternativePhoneNumber = new ArrayList<Patient>();
patientsWithoutPhoneNumber =
getPatientWithoutAgivenConcept(
getConcept(getGlobalProperty("concept.contactPhoneNumber")));
patientsWithoutAlternativePhoneNumber =
getPatientWithoutAgivenConcept(getConcept(getGlobalProperty("concept.phoneNumber")));
for (Patient patient : patientsWithoutPhoneNumber) {
if (patientsWithoutAlternativePhoneNumber.contains(patient)) {
patients.add(patient);
}
}
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.patientWithNoContactInformation");
log.info("bottom patientWithNoContactInformation");
} else if (programIdKey.equals("patientWithNoTRACnet")) {
log.info("top patientWithNoTRACnet");
// log.info("$$$$$$$$$$$$$$$$$$$$$$$$$ this is the tracnet
// type"+getGlobalProperty("patientIdentifierType.TRACnetID"));
patients =
getPatientWithNoGivenIdentifier(getGlobalProperty("patientIdentifierType.TRACnetID"));
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.PatientsWithoutTRACnetID");
log.info("bottom patientWithNoTRACnet");
} else if (programIdKey.equals("patientWithNoNID")) {
log.info("top patientWithNoNID");
patients = getPatientWithNoGivenIdentifier(getGlobalProperty("patientIdentifierType.NID"));
DataqualityFormController.setMsgToDisplay("tracdataquality.indicator.PatientsWithoutNID");
log.info("bottom patientWithNoNID");
} else if (programIdKey.equals("exitedPatientWithProgram")) {
log.info("top exitedPatientWithProgram");
List<Patient> patientsExitedFromCare = new ArrayList<Patient>();
List<Patient> patientWithoutProgram = new ArrayList<Patient>();
patientsExitedFromCare =
getPatientWithAgivenConcept(getConcept(getGlobalProperty("concept.reasonExitedCare")));
patientWithoutProgram = getPatientWithoutProgram();
for (Patient patient : patientsExitedFromCare) {
if (!patientWithoutProgram.contains(patient)) {
patients.add(patient);
}
}
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.exitedPatientWithProgram");
log.info("bottom exitedPatientWithProgram");
} else if (programIdKey.equals("patientInAnyHIVProgramWithNoHIVTestDate")) {
log.info("top patientInAnyHIVProgramWithNoHIVTestDate");
// List<Patient> patientsHIVProgram = new ArrayList<Patient>();
List<Patient> patientsWithoutHIVTestDate = new ArrayList<Patient>();
// ProgramWorkflowService programService = Context.getProgramWorkflowService();
patientsWithoutHIVTestDate =
getPatientWithoutAdmitionModeConcept(
getConcept(getGlobalProperty("concept.HIVTestDate")));
log.info("number of patients with no hiv test date : " + patientsWithoutHIVTestDate.size());
patients.addAll(patientsWithoutHIVTestDate);
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.patientInAnyHIVProgramWithNoHIVTestDate");
log.info("bottom patientInAnyHIVProgramWithNoHIVTestDate");
} else if (programIdKey.equals("PatientsWhoStoppedRegimenAndReasonIsNotRecorded")) {
log.info("top PatientsWhoStoppedRegimenAndReasonIsNotRecorded");
List<Integer> patientIds = new ArrayList<Integer>();
DataQualityService serviceQualityCheck =
((DataQualityService) Context.getService(DataQualityService.class));
patientIds = serviceQualityCheck.getPatientsWhoStoppedDrugWithoutDiscontinuedReason();
for (Integer integer : patientIds) {
Patient patient = getPatientById(integer);
patients.add(patient);
}
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.PatientsWhoStoppedRegimenAndReasonIsNotRecorded");
log.info("bottom PatientsWhoStoppedRegimenAndReasonIsNotRecorded");
} else if (programIdKey.equals("PatientsPediatricsWhoHaveAdultWhoStage")) {
log.info("top PatientsPediatricsWhoHaveAdultWhoStage");
patients = getPatientsPediatricsWhoHaveAdultWhoStage();
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.PatientsPediatricWhoHaveAdultWhoStage");
/*log.info("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@bottom PatientsPediatricsWhoHaveAdultWhoStage"
+ patients);*/
} else if (programIdKey.equals("PatientsAdultWhoHaveChildWhoStage")) {
log.info("top PatientsAdultWhoHaveChildWhoStage");
patients = getPatientsAdultWhoHavePedsWhoStage();
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.PatientsAdultWhoHaveChildWhoStage");
log.info("bottom PatientsAdultWhoHaveChildWhoStage");
} else if (programIdKey.equals("PatientsWhoAreInPMTCTWithNoCPNId")) {
log.info("top PatientsWhoAreInPMTCTWithNoCPNId");
patients = getPatientsWhoAreInPMTCTWithNoCPNId();
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.PatientsInPMTCTWithNoCPNid");
log.info("bottom PatientsWhoAreInPMTCTWithNoCPNId");
} else if (programIdKey.equals("PatientsWithNoReturnVisitDate")) {
log.info("top PatientsWithNoReturnVisitDate");
patients =
getPatientWithoutAgivenConcept(getConcept(getGlobalProperty("concept.returnVisitDate")));
DataqualityFormController.setMsgToDisplay(
"tracdataquality.indicator.PatientsWithNoReturnVisitDate");
log.info("bottom PatientsWithNoReturnVisitDate");
}
DataQualityService serviceQualityCheck =
((DataQualityService) Context.getService(DataQualityService.class));
List<Integer> exitedPatient = serviceQualityCheck.getPatientsExitedFromCare();
// log.info("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"+exitedPatient);
// List<Integer> patientsExited = getPatientsExitedFromCare();
for (Patient patient : patients) {
// && !patientsExited.contains(patient.getPatientId())
// = getPatientsExitedFromCare();
if (!patient.isVoided() && !exitedPatient.contains(patient.getPatientId())) {
activePatients.add(patient);
}
}
Collections.sort(activePatients, new PatientSortByName());
return activePatients;
}
/**
* gets program by programId
*
* @param programId
* @return
*/
public Program getProgramByProgramId(int programId) {
ProgramWorkflowService programService = Context.getProgramWorkflowService();
Program program = programService.getProgram(programId);
return program;
}
@Override
public PatientState newObject() {
return Context.getProgramWorkflowService().getPatientStateByUuid(getUuidProperty());
}
/**
* 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);
}
public int doStartTag() {
records = null;
Locale locale = Context.getLocale();
if (name.equals("patientIdentifierType")) {
PatientService ps = Context.getPatientService();
records = ps.getAllPatientIdentifierTypes().iterator();
} else if (name.equals("relationshipType")) {
PersonService ps = Context.getPersonService();
records = ps.getAllRelationshipTypes().iterator();
} else if (name.equals("encounterType")) {
EncounterService es = Context.getEncounterService();
records = es.getAllEncounterTypes().iterator();
} else if (name.equals("location")) {
LocationService locServ = Context.getLocationService();
records = locServ.getAllLocations().iterator();
} else if (name.equals("locationHierarchy")) {
List<LocationAndDepth> locationAndDepths = new ArrayList<LocationAndDepth>();
List<Location> locations = Context.getLocationService().getRootLocations(true);
populateLocationAndDepthList(locationAndDepths, locations, 0);
records = locationAndDepths.iterator();
} else if (name.equals("cohort")) {
List<Cohort> cohorts = Context.getCohortService().getAllCohorts();
records = cohorts.iterator();
} else if (name.equals("conceptSource")) {
List<ConceptSource> conceptSources = Context.getConceptService().getAllConceptSources(false);
records = conceptSources.iterator();
} else if (name.equals("form")) {
List<Form> forms = Context.getFormService().getAllForms();
records = forms.iterator();
} else if (name.equals("role")) {
List<Role> roles = Context.getUserService().getAllRoles();
records = roles.iterator();
} else if (name.equals("conceptMapType")) {
List<ConceptMapType> mapTypes = Context.getConceptService().getActiveConceptMapTypes();
records = mapTypes.iterator();
} else if (name.equals("civilStatus")) {
ConceptService cs = Context.getConceptService();
Concept civilStatus = cs.getConcept(OpenmrsConstants.CIVIL_STATUS_CONCEPT_ID);
if (civilStatus == null) {
log.error("OpenmrsConstants.CIVIL_STATUS_CONCEPT_ID is defined incorrectly.");
} else {
records = civilStatus.getAnswers(false).iterator();
Map<String, String> opts = new HashMap<String, String>();
for (ConceptAnswer a : civilStatus.getAnswers(false)) {
opts.put(
a.getAnswerConcept().getConceptId().toString(),
a.getAnswerConcept().getShortestName(locale, false).getName());
}
records = opts.entrySet().iterator();
if (select != null) {
select = select.toString() + "=" + opts.get(select);
}
}
} else if (name.equals("gender")) {
Map<String, String> opts = OpenmrsConstants.GENDER();
records = opts.entrySet().iterator();
if (select != null) {
select = select.toString() + "=" + opts.get(select);
}
} else if (name.equals("workflowStatus")) {
List<ProgramWorkflowState> ret = new ArrayList<ProgramWorkflowState>();
records = ret.iterator();
} else if (name.equals("workflowProgram")) {
List<org.openmrs.Program> ret = Context.getProgramWorkflowService().getAllPrograms();
records = ret.iterator();
} else if (name.equals("role")) {
List<Role> ret = Context.getUserService().getAllRoles();
records = ret.iterator();
} else if (name.equals("conceptSet")) {
if (conceptSet == null) {
throw new IllegalArgumentException("Must specify conceptSet");
}
Concept c = Context.getConceptService().getConcept(conceptSet);
if (c == null) {
throw new IllegalArgumentException("Can't find conceptSet " + conceptSet);
}
List<Concept> list = Context.getConceptService().getConceptsByConceptSet(c);
records = list.iterator();
} else if (name.equals("answer")) {
if (concept == null) {
throw new IllegalArgumentException("Must specify concept");
}
Concept c = Context.getConceptService().getConcept(concept);
if (c == null) {
log.error(
"Can't find concept with name or id of: "
+ concept
+ " and so no answers will be returned");
records = null;
} else if (c.getAnswers(false) != null) {
records = c.getAnswers(false).iterator();
} else {
records = new ArrayList<Concept>().iterator();
}
} else {
try {
Class<?> cls = Context.loadClass(name);
Constructor<?> ct = cls.getConstructor();
Iterable<?> iterable = (Iterable<?>) ct.newInstance();
records = iterable.iterator();
} catch (Exception e) {
log.error(name + " not found in ForEachRecord list " + e);
}
}
if (records == null || !records.hasNext()) {
records = null;
return SKIP_BODY;
} else {
return EVAL_BODY_BUFFERED;
}
}
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;
}
