/** * @since 1.5 * @see org.openmrs.OpenmrsObject#getId() */ @Override public Integer getId() { return getEncounterId(); }
/** * Checks for the type of privilege required * * @param encounter which is to be edited */ private boolean requirePrivilege(Encounter encounter) { boolean isNewEncounter = false; if (encounter.getEncounterId() == null) { isNewEncounter = true; Context.requirePrivilege(PrivilegeConstants.ADD_ENCOUNTERS); } else { Context.requirePrivilege(PrivilegeConstants.EDIT_ENCOUNTERS); } return isNewEncounter; }
/** * @see Encounter#Encounter(Integer) */ @Test public void Encounter_shouldSetEncounterId() { Encounter encounter = new Encounter(123); Assert.assertEquals(123, encounter.getEncounterId().intValue()); }
/** * @see org.openmrs.api.db.EncounterDAO#getSavedEncounterDatetime(org.openmrs.Encounter) */ @Override public Date getSavedEncounterDatetime(Encounter encounter) { //Usages of this method currently are internal and don't require a flush //Otherwise we end up with premature flushes of Immutable types like Obs //that are associated to the encounter before we void and replace them Session session = sessionFactory.getCurrentSession(); FlushMode flushMode = session.getFlushMode(); session.setFlushMode(FlushMode.MANUAL); try { SQLQuery sql = session .createSQLQuery("select encounter_datetime from encounter where encounter_id = :encounterId"); sql.setInteger("encounterId", encounter.getEncounterId()); return (Date) sql.uniqueResult(); } finally { session.setFlushMode(flushMode); } }
/** * @see org.openmrs.api.db.EncounterDAO#getSavedEncounterLocation(org.openmrs.Encounter) */ @Override public Location getSavedEncounterLocation(Encounter encounter) { Session session = sessionFactory.getCurrentSession(); FlushMode flushMode = session.getFlushMode(); session.setFlushMode(FlushMode.MANUAL); try { SQLQuery sql = session.createSQLQuery("select location_id from encounter where encounter_id = :encounterId"); sql.setInteger("encounterId", encounter.getEncounterId()); return Context.getLocationService().getLocation((Integer) sql.uniqueResult()); } finally { session.setFlushMode(flushMode); } }
/** * @throws ParseException * @see EncounterService#getEncounters(Patient, Location, Date, Date, java.util.Collection, * java.util.Collection, java.util.Collection, boolean) */ @Test public void getEncounters_shouldGetEncountersOnOrUpToADate() throws ParseException { Date toDate = new SimpleDateFormat("yyyy-dd-MM").parse("2006-01-01"); EncounterSearchCriteria encounterSearchCriteria = new EncounterSearchCriteriaBuilder().setToDate(toDate) .setIncludeVoided(true).createEncounterSearchCriteria(); List<Encounter> encounters = Context.getEncounterService().getEncounters(encounterSearchCriteria); assertEquals(2, encounters.size()); assertEquals(15, encounters.get(0).getEncounterId().intValue()); assertEquals(1, encounters.get(1).getEncounterId().intValue()); }
private void mergeEncounters(Patient preferred, Patient notPreferred, PersonMergeLogData mergedData) { // change all encounters. This will cascade to obs and orders contained in those encounters // TODO: this should be a copy, not a move EncounterService es = Context.getEncounterService(); EncounterSearchCriteria notPreferredPatientEncounterSearchCriteria = new EncounterSearchCriteriaBuilder() .setIncludeVoided(true) .setPatient(notPreferred) .createEncounterSearchCriteria(); for (Encounter e : es.getEncounters(notPreferredPatientEncounterSearchCriteria)) { e.setPatient(preferred); log.debug("Merging encounter " + e.getEncounterId() + " to " + preferred.getPatientId()); Encounter persisted = es.saveEncounter(e); mergedData.addMovedEncounter(persisted.getUuid()); } }
/** * @see EncounterService#getEncounterByUuid(String) */ @Test public void getEncounterByUuid_shouldFindObjectGivenValidUuid() { String uuid = "6519d653-393b-4118-9c83-a3715b82d4ac"; Encounter encounter = Context.getEncounterService().getEncounterByUuid(uuid); Assert.assertEquals(3, (int) encounter.getEncounterId()); }
/** * @see EncounterService#saveEncounter(Encounter) */ @Test public void saveEncounter_shouldSaveEncounterWithBasicDetails() { Encounter encounter = buildEncounter(); EncounterService es = Context.getEncounterService(); es.saveEncounter(encounter); assertNotNull("The saved encounter should have an encounter id now", encounter.getEncounterId()); Encounter newSavedEncounter = es.getEncounter(encounter.getEncounterId()); assertNotNull("We should get back an encounter", newSavedEncounter); assertTrue("The created encounter needs to equal the pojo encounter", encounter.equals(newSavedEncounter)); }
List<Encounter> encounters = Context.getEncounterService().getEncounters(encounterSearchCriteria); assertEquals(5, encounters.size()); assertEquals(1, encounters.get(0).getEncounterId().intValue()); encounters = Context.getEncounterService().getEncounters(encounterSearchCriteria); assertEquals(4, encounters.size()); assertEquals(3, encounters.get(0).getEncounterId().intValue()); assertEquals(4, encounters.get(1).getEncounterId().intValue()); assertEquals(5, encounters.get(2).getEncounterId().intValue());
/** * This method assigns a visit to a new encounter using the registered visit assignment handler * * @param encounter a new encounter */ private void createVisitForNewEncounter(Encounter encounter) { if (encounter.getEncounterId() == null) { //Am using Context.getEncounterService().getActiveEncounterVisitHandler() instead of just //getActiveEncounterVisitHandler() for modules which may want to AOP around this call. EncounterVisitHandler encounterVisitHandler = Context.getEncounterService().getActiveEncounterVisitHandler(); if (encounterVisitHandler != null) { encounterVisitHandler.beforeCreateEncounter(encounter); //If we have been assigned a new visit, persist it. if (encounter.getVisit() != null && encounter.getVisit().getVisitId() == null) { Context.getVisitService().saveVisit(encounter.getVisit()); } } } }
/** * Make sure that purging an encounter removes the row from the database * * @see EncounterService#purgeEncounter(Encounter) */ @Test public void purgeEncounter_shouldPurgeEncounter() { EncounterService es = Context.getEncounterService(); // fetch the encounter to delete from the db Encounter encounterToDelete = es.getEncounter(1); es.purgeEncounter(encounterToDelete); // try to refetch the encounter. should get a null object Encounter e = es.getEncounter(encounterToDelete.getEncounterId()); assertNull("We shouldn't find the encounter after deletion", e); }
/** * @see VisitService#saveVisit(Visit) */ @Test public void saveVisit_shouldAssociateEncounterWithVisitOnSaveEncounter() { Visit visit = visitService.getVisit(1); EncounterService es = Context.getEncounterService(); Encounter encounter = new Encounter(); encounter.setEncounterDatetime(new Date()); encounter.setPatient(visit.getPatient()); encounter.setLocation(visit.getLocation()); encounter.setEncounterType(es.getEncounterType(1)); visit.addEncounter(encounter); Context.getEncounterService().saveEncounter(encounter); Integer encounterId = encounter.getEncounterId(); Context.flushSession(); Context.clearSession(); // reload the visit visit = visitService.getVisit(1); assertEquals(1, visit.getEncounters().size()); assertEquals(encounterId, ((Encounter) visit.getEncounters().toArray()[0]).getEncounterId()); }
assertEquals(originalSize + 1, visitService.getAllVisits().size()); assertEquals(1, visit.getEncounters().size()); assertEquals(Integer.valueOf(4), ((Encounter) visit.getEncounters().toArray()[0]).getEncounterId());
Encounter newEncounter = encounterService.getEncounter(encounter.getEncounterId()); assertNotNull(newEncounter); assertEquals(DateUtil.truncateToSeconds(date), encounter.getDateCreated());
/** * @see EncounterService#saveEncounter(Encounter) */ @Test public void saveEncounter_shouldNotOverwriteCreatorIfNonNull() { EncounterService encounterService = Context.getEncounterService(); // the encounter to save with a non null creator Encounter encounter = buildEncounter(); encounter.setCreator(new User(4)); // make sure the logged in user isn't the user we're testing with assertNotSame(encounter.getCreator(), Context.getAuthenticatedUser()); encounterService.saveEncounter(encounter); // make sure the encounter creator is user 4 not user 1 assertEquals(4, encounter.getCreator().getId().intValue()); // make sure we can fetch this new encounter // from the database and its values are the same as the passed in ones Encounter newEncounter = encounterService.getEncounter(encounter.getEncounterId()); assertNotNull(newEncounter); assertEquals(4, encounter.getCreator().getId().intValue()); assertNotSame(encounter.getCreator(), Context.getAuthenticatedUser()); }
encounter = es.getEncounter(encounter.getEncounterId());
encounter = encounterService.getEncounter(encounter.getEncounterId()); assertEquals(1, encounter.getProvidersByRoles().size());
/** * Make sure that purging an encounter removes the row from the database * * @see EncounterService#purgeEncounter(Encounter,null) */ @Test public void purgeEncounter_shouldCascadePurgeToObsAndOrders() { EncounterService es = Context.getEncounterService(); // fetch the encounter to delete from the db Encounter encounterToDelete = es.getEncounter(1); es.purgeEncounter(encounterToDelete, true); // try to refetch the encounter. should get a null object Encounter e = es.getEncounter(encounterToDelete.getEncounterId()); assertNull("We shouldn't find the encounter after deletion", e); ObsService obsService = Context.getObsService(); assertNull(obsService.getObs(1)); assertNull(obsService.getObs(2)); assertNull(obsService.getObs(3)); assertNull(Context.getOrderService().getOrder(1)); }
Encounter newestEnc = es.getEncounter(encounter.getEncounterId());