How to use

ProgramWorkflowService

in

org.openmrs.api

  Integer conceptId = Integer.valueOf(text.substring(text.indexOf('.') + 1));
  Concept c = Context.getConceptService().getConcept(conceptId);
  setValue(Context.getProgramWorkflowService().getProgramByName(c.getName().getName()));
} else {
  Integer programId = Integer.valueOf(text);
  setValue(Context.getProgramWorkflowService().getProgram(programId));
if (text.startsWith("concept.")) {
  Concept c = Context.getConceptService().getConceptByUuid(text.substring(text.indexOf('.') + 1));
  p = Context.getProgramWorkflowService().getProgramByName(c.getName().getName());
} else {
  p = Context.getProgramWorkflowService().getProgramByUuid(text);

@Test
public void purgeProgram_shouldPurgeProgramWithPatientsEnrolled() {
  Program program = Context.getProgramWorkflowService().getProgram(2);
  
  // program has at least one patient enrolled
  List<PatientProgram> patientPrograms = Context.getProgramWorkflowService().getPatientPrograms(null, program, null,
    null, null, null, true);
  assertTrue(patientPrograms.size() > 0);
  
  Context.getProgramWorkflowService().purgeProgram(program);
  
  // should cascade to patient programs
  for (PatientProgram patientProgram : patientPrograms) {
    assertNull(Context.getProgramWorkflowService().getPatientProgram(patientProgram.getId()));
  }
  // make sure that the program was deleted properly
  assertNull(Context.getProgramWorkflowService().getProgram(2));
}
@Test

  @Override
  protected ProgramWorkflowState getExistingObject() {
    return programWorkflowService.getStateByUuid(EXISTING_UUID);
  }
}

private void mergeProgramEnrolments(Patient preferred, Patient notPreferred, PersonMergeLogData mergedData) {
  // copy all program enrollments
  ProgramWorkflowService programService = Context.getProgramWorkflowService();
  for (PatientProgram pp : programService.getPatientPrograms(notPreferred, null, null, null, null, null, false)) {
    if (!pp.getVoided()) {
      PatientProgram enroll = pp.copy();
      enroll.setPatient(preferred);
      log.debug("Copying patientProgram " + pp.getPatientProgramId() + " to " + preferred.getPatientId());
      PatientProgram persisted = programService.savePatientProgram(enroll);
      mergedData.addCreatedProgram(persisted.getUuid());
    }
  }
}

@Test
public void getProgramByName_shouldCallDaoGetProgramsByName() {
  ProgramWorkflowDAO mockDao = Mockito.mock(ProgramWorkflowDAO.class);
  pws.setProgramWorkflowDAO(mockDao);
  pws.getProgramByName("A name");
  Mockito.verify(mockDao).getProgramsByName("A name", false);
  Mockito.verify(mockDao).getProgramsByName("A name", true);
}

@Override
public void testResults(SubmissionResults results) {
  results.assertNoErrors();
  results.assertEncounterCreated();
  List<PatientProgram> pps = pws.getPatientPrograms(ps.getPatient(patientId), pws.getProgram(programId), null,
    null, null, null, false);
  Assert.assertEquals(1, pps.size());
  
  // make sure the state has been set
  Set<PatientState> states = pps.get(0).getStates();
  Assert.assertEquals(1, states.size());
  Assert.assertTrue(((PatientState) states.toArray()[0]).getState().equals(Context.getProgramWorkflowService().getStateByUuid("6de7ed10-53ad-11e1-8cb6-00248140a5eb")));
};
 

Assert.assertFalse(dependencies.contains(Context.getProgramWorkflowService().getProgramByUuid(
  "da4a0391-ba62-4fad-ad66-1e3722d16380")));
Assert.assertFalse(dependencies.contains(Context.getProgramWorkflowService().getProgramByUuid(
  "71779c39-d289-4dfe-91b5-e7cfaa27c78b")));
Assert.assertTrue(dependencies.contains(Context.getProgramWorkflowService().getWorkflowByUuid(
  "72a90efc-5140-11e1-a3e3-00248140a5eb")));
Assert.assertTrue(dependencies.contains(Context.getProgramWorkflowService().getWorkflowByUuid(
  "7c3e071a-53a7-11e1-8cb6-00248140a5eb")));
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")));

@Override
public void testResults(SubmissionResults results) {
  results.assertNoErrors();
  results.assertEncounterCreated();
  List<PatientProgram> pps = pws.getPatientPrograms(ps.getPatient(patientId), pws.getProgram(programId), null,
    null, null, null, false);
  Assert.assertEquals(1, pps.size());
  
  //the user selected date should have been set
  Assert.assertEquals(ymdToDate(dateAsString(enrollmentDate)), ymdToDate(dateAsString(pps.get(0)
      .getDateEnrolled())));
  
  //the initial state should have been set
  Assert.assertEquals(1, pps.get(0).getStates().size());
  Assert.assertEquals(200,
    pps.get(0).getCurrentState(pws.getWorkflowByUuid("72a90efc-5140-11e1-a3e3-00248140a5eb")).getState()
        .getId().intValue());
};
 

@Override
public void testResults(SubmissionResults results) {
  results.assertNoErrors();
  results.assertEncounterCreated();
  List<PatientProgram> pps = pws.getPatientPrograms(ps.getPatient(patientId), pws.getProgram(programId), null,
    null, null, null, false);
  Assert.assertEquals(1, pps.size());
  
  //the encounter date should have been set as the enrollment date
  Assert.assertEquals(ymdToDate(dateAsString(encounterDate)), ymdToDate(dateAsString(pps.get(0)
      .getDateEnrolled())));
};
 

  /**
   * @see org.openmrs.customdatatype.SerializingCustomDatatype#deserialize(java.lang.String)
   * @should return the object by given uuid string
   * @override
   */
  @Override
  public Program deserialize(String uuid) {
    if (StringUtils.isBlank(uuid)) {
      return null;
    }
    return Context.getProgramWorkflowService().getProgramByUuid(uuid);
  }
}

@SuppressWarnings("deprecation")
@Override
public void testEditedResults(SubmissionResults results) {
  // do all the basic assertions to make sure the program was processed correctly
  results.assertNoErrors();
  results.assertEncounterCreated();
  results.assertProvider(502);
  results.assertLocation(2);
  
  // confirm that that patient is no longer in the program
  Patient patient = Context.getPatientService().getPatient(2);
  Program program = Context.getProgramWorkflowService().getProgram(1);
  Assert.assertFalse("Patient should no longer be in program", Context.getProgramWorkflowService().isInProgram(patient, program, new Date(), null));
  
  // but confirm that the patient was in the program in the past
  Assert.assertTrue("Patient should still be in program in the past", Context.getProgramWorkflowService().isInProgram(patient, program, null, new Date()));	
  
  // confirm that the proper program has been closed
  PatientProgram pp = Context.getProgramWorkflowService().getPatientProgramByUuid("32296060-03aa-102d-b0e3-001ec94a0cc5");
  Assert.assertTrue("Program completion date should be current date", TestUtil.dateEquals(new Date(), pp.getDateCompleted()));
};
 

/**
 * @see ProgramWorkflowService#getPatientProgramByUuid(String)
 */
@Test
public void getPatientProgramByUuid_shouldReturnNullIfNoObjectFoundWithGivenUuid() {
  Assert.assertNull(Context.getProgramWorkflowService().getPatientProgramByUuid("some invalid uuid"));
}

/**
 * @see org.openmrs.api.ProgramWorkflowService#getPossibleOutcomes(Integer)
 */
@Override
@Transactional(readOnly = true)
public List<Concept> getPossibleOutcomes(Integer programId) {
  List<Concept> possibleOutcomes = new ArrayList<>();
  Program program = Context.getProgramWorkflowService().getProgram(programId);
  if (program == null) {
    return possibleOutcomes;
  }
  Concept outcomesConcept = program.getOutcomesConcept();
  if (outcomesConcept == null) {
    return possibleOutcomes;
  }
  if (!outcomesConcept.getAnswers().isEmpty()) {
    for (ConceptAnswer conceptAnswer : outcomesConcept.getAnswers()) {
      possibleOutcomes.add(conceptAnswer.getAnswerConcept());
    }
    return possibleOutcomes;
  }
  if (!outcomesConcept.getSetMembers().isEmpty()) {
    return outcomesConcept.getSetMembers();
  }
  return possibleOutcomes;
}

private void enrollInProgram(String state, Date date) {
  ProgramWorkflowState workflowState = Context.getProgramWorkflowService().getStateByUuid(state);
  
  PatientProgram patientProgram = getPatientProgramByWorkflow(patient, workflowState.getProgramWorkflow(), date);
  if (patientProgram == null) {
    patientProgram = new PatientProgram();
    patientProgram.setPatient(patient);
    patientProgram.setProgram(workflowState.getProgramWorkflow().getProgram());
    patientProgram.setDateEnrolled(date);
  }
  
  Context.getProgramWorkflowService().savePatientProgram(patientProgram);
}
 

@Override
public Program getByUniqueId(String uniqueId) {
  Program programByUuid = Context.getProgramWorkflowService().getProgramByUuid(uniqueId);
  //We assume the caller was fetching by name
  if (programByUuid == null) {
    programByUuid = Context.getProgramWorkflowService().getProgramByName(uniqueId);
  }
  return programByUuid;
}

/**
 * @see org.openmrs.api.ProgramWorkflowService#getAllPrograms()
 */
@Override
@Transactional(readOnly = true)
public List<Program> getAllPrograms() throws APIException {
  return Context.getProgramWorkflowService().getAllPrograms(true);
}

/**
 * @see org.openmrs.api.ProgramWorkflowService#getProgram(java.lang.String)
 */
@Transactional(readOnly = true)
public Program getProgram(String name) {
  return Context.getProgramWorkflowService().getProgramByName(name);
}

Map<String, PatientProgram> knownPatientPrograms = new HashMap<>();
Map<String, Program> programsByName = new HashMap<>();
for (Program program : pws.getAllPrograms()) {
  programsByName.put(program.getConcept().getName(Context.getLocale(), false).getName(), program);
  pws.savePatientProgram(pp);
  ++numAdded;

public void saveProgram_shouldCreateProgramWorkflows() {
  int numBefore = Context.getProgramWorkflowService().getAllPrograms().size();
  workflow.addState(state2);
  Context.getProgramWorkflowService().saveProgram(program);
  assertEquals("Failed to create program", numBefore + 1, Context.getProgramWorkflowService().getAllPrograms().size());
  Program p = Context.getProgramWorkflowService().getProgramByName("TEST PROGRAM");
  assertNotNull("Program is null", p);
  assertNotNull("Workflows is null", p.getWorkflows());

  @Override
  protected ProgramWorkflow getExistingObject() {
    return programWorkflowService.getWorkflowByUuid(EXISTING_UUID);
  }
}