diff --git a/sormas-backend/src/main/java/de/symeda/sormas/backend/caze/CaseQueryContext.java b/sormas-backend/src/main/java/de/symeda/sormas/backend/caze/CaseQueryContext.java index cee6c54045a5..fb8c5200ec62 100644 --- a/sormas-backend/src/main/java/de/symeda/sormas/backend/caze/CaseQueryContext.java +++ b/sormas-backend/src/main/java/de/symeda/sormas/backend/caze/CaseQueryContext.java @@ -21,6 +21,10 @@ public CaseQueryContext(CriteriaBuilder cb, CriteriaQuery query, From(root)); } + public CaseQueryContext(CriteriaBuilder cb, CriteriaQuery query, CaseJoins joins) { + super(cb, query, joins.getRoot(), joins); + } + @Override protected Expression createExpression(String name) { diff --git a/sormas-backend/src/main/java/de/symeda/sormas/backend/contact/ContactJoins.java b/sormas-backend/src/main/java/de/symeda/sormas/backend/contact/ContactJoins.java index ca7f92cbb980..c88f7d493349 100644 --- a/sormas-backend/src/main/java/de/symeda/sormas/backend/contact/ContactJoins.java +++ b/sormas-backend/src/main/java/de/symeda/sormas/backend/contact/ContactJoins.java @@ -32,16 +32,17 @@ import de.symeda.sormas.backend.infrastructure.region.Region; import de.symeda.sormas.backend.location.Location; import de.symeda.sormas.backend.person.Person; +import de.symeda.sormas.backend.person.PersonJoins; import de.symeda.sormas.backend.sample.Sample; import de.symeda.sormas.backend.symptoms.Symptoms; import de.symeda.sormas.backend.user.User; import de.symeda.sormas.backend.util.AbstractDomainObjectJoins; import de.symeda.sormas.backend.visit.Visit; +import de.symeda.sormas.utils.CaseJoins; public class ContactJoins extends AbstractDomainObjectJoins { private Join person; -// private CaseJoins caseJoins; private Join caze; private Join resultingCase; private Join casePerson; @@ -86,10 +87,11 @@ public class ContactJoins extends AbstractDomainObjectJoins { private Join followUpStatusChangeUser; + private CaseJoins caseJoins; + private PersonJoins personJoins; + public ContactJoins(From contact) { super(contact); - -// this.caseJoins = new CaseJoins<>(contact.join(Contact.CAZE)); } public Join getPerson() { @@ -395,4 +397,20 @@ public Join getFollowUpStatusChangeUser() { private void setFollowUpStatusChangeUser(Join followUpStatusChangeUser) { this.followUpStatusChangeUser = followUpStatusChangeUser; } + + public CaseJoins getCaseJoins() { + return getOrCreate(caseJoins, () -> new CaseJoins(getCaze()), this::setCaseJoins); + } + + private void setCaseJoins(CaseJoins caseJoins) { + this.caseJoins = caseJoins; + } + + public PersonJoins getPersonJoins() { + return getOrCreate(personJoins, () -> new PersonJoins(getPerson()), this::setPersonJoins); + } + + private void setPersonJoins(PersonJoins personJoins) { + this.personJoins = personJoins; + } } diff --git a/sormas-backend/src/main/java/de/symeda/sormas/backend/contact/ContactQueryContext.java b/sormas-backend/src/main/java/de/symeda/sormas/backend/contact/ContactQueryContext.java index b10538c5d873..575b21b6ab3a 100644 --- a/sormas-backend/src/main/java/de/symeda/sormas/backend/contact/ContactQueryContext.java +++ b/sormas-backend/src/main/java/de/symeda/sormas/backend/contact/ContactQueryContext.java @@ -20,6 +20,10 @@ public ContactQueryContext(CriteriaBuilder cb, CriteriaQuery query, From query, ContactJoins joins) { + super(cb, query, joins.getRoot(), joins); + } + @Override protected Expression createExpression(String name) { diff --git a/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskFacadeEjb.java b/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskFacadeEjb.java index 2ca93bcab574..d19a4d630992 100644 --- a/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskFacadeEjb.java +++ b/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskFacadeEjb.java @@ -678,8 +678,8 @@ public List getExportList(TaskCriteria criteria, Collection caseQueryContext = new CaseQueryContext<>(cb, cq, joins.getCaze()); ContactQueryContext contactQueryContext = new ContactQueryContext<>(cb, cq, joins.getContact()); - LocationJoins casePersonAddressJoins = joins.getCasePersonJoins().getAddressJoins(); - LocationJoins contactPersonAddressJoins = joins.getContactPersonJoins().getAddressJoins(); + LocationJoins casePersonAddressJoins = joins.getCaseJoins().getPersonJoins().getAddressJoins(); + LocationJoins contactPersonAddressJoins = joins.getContactJoins().getPersonJoins().getAddressJoins(); //@formatter:off cq.multiselect(task.get(Task.UUID), task.get(Task.TASK_CONTEXT), diff --git a/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskJoins.java b/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskJoins.java index 7aa19380a1bc..66cb3a8155e1 100644 --- a/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskJoins.java +++ b/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskJoins.java @@ -23,15 +23,13 @@ import de.symeda.sormas.backend.caze.Case; import de.symeda.sormas.backend.contact.Contact; +import de.symeda.sormas.backend.contact.ContactJoins; import de.symeda.sormas.backend.event.Event; -import de.symeda.sormas.backend.infrastructure.facility.Facility; -import de.symeda.sormas.backend.infrastructure.pointofentry.PointOfEntry; -import de.symeda.sormas.backend.location.Location; -import de.symeda.sormas.backend.person.Person; -import de.symeda.sormas.backend.person.PersonJoins; import de.symeda.sormas.backend.infrastructure.community.Community; import de.symeda.sormas.backend.infrastructure.district.District; import de.symeda.sormas.backend.infrastructure.region.Region; +import de.symeda.sormas.backend.location.Location; +import de.symeda.sormas.backend.person.Person; import de.symeda.sormas.backend.travelentry.TravelEntry; import de.symeda.sormas.backend.user.User; import de.symeda.sormas.backend.util.AbstractDomainObjectJoins; @@ -40,7 +38,6 @@ public class TaskJoins extends AbstractDomainObjectJoins { private Join caze; - private Join casePerson; private Join event; private Join eventReportingUser; private Join eventResponsibleUser; @@ -49,38 +46,10 @@ public class TaskJoins extends AbstractDomainObjectJoins { private Join eventDistrict; private Join eventCommunity; private Join contact; - private Join contactPerson; - private Join contactCase; - private Join contactCasePerson; private Join creator; private Join assignee; - private Join caseReportingUser; - private Join caseResponsibleRegion; - private Join caseResponsibleDistrict; - private Join caseResponsibleCommunity; - private Join caseRegion; - private Join caseDistrict; - private Join caseCommunity; - private Join caseFacility; - private Join casePointOfEntry; - private Join contactReportingUser; - private Join contactRegion; - private Join contactDistrict; - private Join contactCommunity; - private Join contactCaseReportingUser; - private Join contactCaseResponsibleRegion; - private Join contactCaseResponsibleDistrict; - private Join contactCaseResponsibleCommunity; - private Join contactCaseRegion; - private Join contactCaseDistrict; - private Join contactCaseCommunity; - private Join contactCaseHealthFacility; - private Join contactCasePointOfEntry; - private Join casePersonAddress; - private Join contactPersonAddress; - private final CaseJoins caseJoins; - private final PersonJoins contactPersonJoins; - private final PersonJoins casePersonJoins; + private CaseJoins caseJoins; + private ContactJoins contactJoins; private Join travelEntry; private Join travelEntryResponsibleRegion; private Join travelEntryResponsibleDistrict; @@ -89,14 +58,6 @@ public class TaskJoins extends AbstractDomainObjectJoins { public TaskJoins(From root) { super(root); - - caseJoins = new CaseJoins<>(getCaze()); - casePersonJoins = new PersonJoins<>(getCasePerson()); - contactPersonJoins = new PersonJoins<>(getContactPerson()); - } - - public CaseJoins getCaseJoins() { - return caseJoins; } public Join getCaze() { @@ -108,11 +69,7 @@ private void setCaze(Join caze) { } public Join getCasePerson() { - return getOrCreate(casePerson, Case.PERSON, JoinType.LEFT, getCaze(), this::setCasePerson); - } - - private void setCasePerson(Join casePerson) { - this.casePerson = casePerson; + return getCaseJoins().getPerson(); } public Join getEvent() { @@ -235,27 +192,15 @@ private void setContact(Join contact) { } public Join getContactPerson() { - return getOrCreate(contactPerson, Contact.PERSON, JoinType.LEFT, getContact(), this::setContactPerson); - } - - private void setContactPerson(Join contactPerson) { - this.contactPerson = contactPerson; + return getContactJoins().getPerson(); } public Join getContactCase() { - return getOrCreate(contactCase, Contact.CAZE, JoinType.LEFT, getContact(), this::setContactCase); - } - - private void setContactCase(Join contactCase) { - this.contactCase = contactCase; + return getContactJoins().getCaze(); } public Join getContactCasePerson() { - return getOrCreate(contactCasePerson, Case.PERSON, JoinType.LEFT, getContactCase(), this::setContactCasePerson); - } - - private void setContactCasePerson(Join contactCasePerson) { - this.contactCasePerson = contactCasePerson; + return getContactJoins().getCaseJoins().getPerson(); } public Join getCreator() { @@ -274,218 +219,63 @@ private void setAssignee(Join assignee) { this.assignee = assignee; } - public Join getCaseReportingUser() { - return getOrCreate(caseReportingUser, Case.REPORTING_USER, JoinType.LEFT, getCaze(), this::setCaseReportingUser); - } - - private void setCaseReportingUser(Join caseReportingUser) { - this.caseReportingUser = caseReportingUser; - } - public Join getCaseResponsibleRegion() { - return getOrCreate(caseResponsibleRegion, Case.RESPONSIBLE_REGION, JoinType.LEFT, getCaze(), this::setCaseResponsibleRegion); - } - - private void setCaseResponsibleRegion(Join caseResponsibleRegion) { - this.caseResponsibleRegion = caseResponsibleRegion; + return getCaseJoins().getResponsibleRegion(); } public Join getCaseResponsibleDistrict() { - return getOrCreate(caseResponsibleDistrict, Case.RESPONSIBLE_DISTRICT, JoinType.LEFT, getCaze(), this::setCaseResponsibleDistrict); - } - - private void setCaseResponsibleDistrict(Join caseResponsibleDistrict) { - this.caseResponsibleDistrict = caseResponsibleDistrict; + return getCaseJoins().getResponsibleDistrict(); } public Join getCaseResponsibleCommunity() { - return getOrCreate(caseResponsibleCommunity, Case.RESPONSIBLE_COMMUNITY, JoinType.LEFT, getCaze(), this::setCaseResponsibleCommunity); - } - - private void setCaseResponsibleCommunity(Join caseResponsibleCommunity) { - this.caseResponsibleCommunity = caseResponsibleCommunity; + return getCaseJoins().getResponsibleCommunity(); } public Join getCaseRegion() { - return getOrCreate(caseRegion, Case.REGION, JoinType.LEFT, getCaze(), this::setCaseRegion); - } - - private void setCaseRegion(Join caseRegion) { - this.caseRegion = caseRegion; + return getCaseJoins().getRegion(); } public Join getCaseDistrict() { - return getOrCreate(caseDistrict, Case.DISTRICT, JoinType.LEFT, getCaze(), this::setCaseDistrict); - } - - private void setCaseDistrict(Join caseDistrict) { - this.caseDistrict = caseDistrict; + return getCaseJoins().getDistrict(); } public Join getCaseCommunity() { - return getOrCreate(caseCommunity, Case.COMMUNITY, JoinType.LEFT, getCaze(), this::setCaseCommunity); - } - - private void setCaseCommunity(Join caseCommunity) { - this.caseCommunity = caseCommunity; - } - - public Join getCaseFacility() { - return getOrCreate(caseFacility, Case.HEALTH_FACILITY, JoinType.LEFT, getCaze(), this::setCaseFacility); - } - - private void setCaseFacility(Join caseFacility) { - this.caseFacility = caseFacility; - } - - public Join getCasePointOfEntry() { - return getOrCreate(casePointOfEntry, Case.POINT_OF_ENTRY, JoinType.LEFT, getCaze(), this::setCasePointOfEntry); - } - - private void setCasePointOfEntry(Join casePointOfEntry) { - this.casePointOfEntry = casePointOfEntry; - } - - public Join getContactReportingUser() { - return getOrCreate(contactReportingUser, Contact.REPORTING_USER, JoinType.LEFT, getContact(), this::setContactReportingUser); - } - - private void setContactReportingUser(Join contactReportingUser) { - this.contactReportingUser = contactReportingUser; + return getCaseJoins().getCommunity(); } public Join getContactRegion() { - return getOrCreate(contactRegion, Contact.REGION, JoinType.LEFT, getContact(), this::setContactRegion); - } - - private void setContactRegion(Join contactRegion) { - this.contactRegion = contactRegion; + return getContactJoins().getRegion(); } public Join getContactDistrict() { - return getOrCreate(contactDistrict, Contact.DISTRICT, JoinType.LEFT, getContact(), this::setContactDistrict); - } - - private void setContactDistrict(Join contactDistrict) { - this.contactDistrict = contactDistrict; + return getContactJoins().getDistrict(); } public Join getContactCommunity() { - return getOrCreate(contactCommunity, Contact.COMMUNITY, JoinType.LEFT, getContact(), this::setContactCommunity); + return getContactJoins().getCommunity(); } - public void setContactCommunity(Join contactCommunity) { - this.contactCommunity = contactCommunity; - } - - public Join getContactCaseReportingUser() { - return getOrCreate(contactCaseReportingUser, Case.REPORTING_USER, JoinType.LEFT, getContactCase(), this::setContactCaseReportingUser); - } - - private void setContactCaseReportingUser(Join contactCaseReportingUser) { - this.contactCaseReportingUser = contactCaseReportingUser; - } - - public Join getContactCaseResponsibleRegion() { - return getOrCreate( - contactCaseResponsibleRegion, - Case.RESPONSIBLE_REGION, - JoinType.LEFT, - getContactCase(), - this::setContactCaseResponsibleRegion); - } - - private void setContactCaseResponsibleRegion(Join contactCaseResponsibleRegion) { - this.contactCaseResponsibleRegion = contactCaseResponsibleRegion; - } - - public Join getContactCaseResponsibleDistrict() { - return getOrCreate( - contactCaseResponsibleDistrict, - Case.RESPONSIBLE_DISTRICT, - JoinType.LEFT, - getContactCase(), - this::setContactCaseResponsibleDistrict); - } - - private void setContactCaseResponsibleDistrict(Join contactCaseResponsibleDistrict) { - this.contactCaseResponsibleDistrict = contactCaseResponsibleDistrict; - } - - public Join getContactCaseResponsibleCommunity() { - return getOrCreate( - contactCaseResponsibleCommunity, - Case.RESPONSIBLE_COMMUNITY, - JoinType.LEFT, - getContactCase(), - this::setContactCaseResponsibleCommunity); - } - - private void setContactCaseResponsibleCommunity(Join contactCaseResponsibleCommunity) { - this.contactCaseResponsibleCommunity = contactCaseResponsibleCommunity; - } - - public Join getContactCaseRegion() { - return getOrCreate(contactCaseRegion, Case.REGION, JoinType.LEFT, getContactCase(), this::setContactCaseRegion); - } - - private void setContactCaseRegion(Join contactCaseRegion) { - this.contactCaseRegion = contactCaseRegion; - } - - public Join getContactCaseDistrict() { - return getOrCreate(contactCaseDistrict, Case.DISTRICT, JoinType.LEFT, getContactCase(), this::setContactCaseDistrict); - } - - private void setContactCaseDistrict(Join contactCaseDistrict) { - this.contactCaseDistrict = contactCaseDistrict; - } - - public Join getContactCaseCommunity() { - return getOrCreate(contactCaseCommunity, Case.COMMUNITY, JoinType.LEFT, getContactCase(), this::setContactCaseCommunity); - } - - private void setContactCaseCommunity(Join contactCaseCommunity) { - this.contactCaseCommunity = contactCaseCommunity; - } - - public Join getContactCaseHealthFacility() { - return getOrCreate(contactCaseHealthFacility, Case.HEALTH_FACILITY, JoinType.LEFT, getContactCase(), this::setContactCaseHealthFacility); - } - - private void setContactCaseHealthFacility(Join contactCaseHealthFacility) { - this.contactCaseHealthFacility = contactCaseHealthFacility; - } - - public Join getContactCasePointOfEntry() { - return getOrCreate(contactCasePointOfEntry, Case.POINT_OF_ENTRY, JoinType.LEFT, getContactCase(), this::setContactCasePointOfEntry); - } - - private void setContactCasePointOfEntry(Join contactCasePointOfEntry) { - this.contactCasePointOfEntry = contactCasePointOfEntry; - } - - public PersonJoins getCasePersonJoins() { - return casePersonJoins; + public Join getCasePersonAddress() { + return getCaseJoins().getPersonJoins().getAddress(); } - public PersonJoins getContactPersonJoins() { - return contactPersonJoins; + public Join getContactPersonAddress() { + return getContactJoins().getPersonJoins().getAddress(); } - public Join getCasePersonAddress() { - return getOrCreate(casePersonAddress, Person.ADDRESS, JoinType.LEFT, getCasePerson(), this::setCasePersonAddress); + public CaseJoins getCaseJoins() { + return getOrCreate(caseJoins, () -> new CaseJoins(getCaze()), this::setCaseJoins); } - private void setCasePersonAddress(Join casePersonAddress) { - this.casePersonAddress = casePersonAddress; + private void setCaseJoins(CaseJoins caseJoins) { + this.caseJoins = caseJoins; } - public Join getContactPersonAddress() { - return getOrCreate(contactPersonAddress, Person.ADDRESS, JoinType.LEFT, getContactPerson(), this::setContactPersonAddress); + public ContactJoins getContactJoins() { + return getOrCreate(contactJoins, () -> new ContactJoins(getContact()), this::setContactJoins); } - private void setContactPersonAddress(Join contactPersonAddress) { - this.contactPersonAddress = contactPersonAddress; + private void setContactJoins(ContactJoins contactJoins) { + this.contactJoins = contactJoins; } } diff --git a/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskJurisdictionPredicateValidator.java b/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskJurisdictionPredicateValidator.java index f71330fadd71..504637f5e123 100644 --- a/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskJurisdictionPredicateValidator.java +++ b/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskJurisdictionPredicateValidator.java @@ -49,9 +49,10 @@ public static TaskJurisdictionPredicateValidator of(TaskQueryContext qc, User us final CriteriaBuilder cb = qc.getCriteriaBuilder(); final TaskJoins joins = (TaskJoins) qc.getJoins(); - associatedJurisdictionValidators.add(CaseJurisdictionPredicateValidator.of(new CaseQueryContext(cb, qc.getQuery(), joins.getCaze()), user)); associatedJurisdictionValidators - .add(ContactJurisdictionPredicateValidator.of(new ContactQueryContext(cb, qc.getQuery(), joins.getContact()), user)); + .add(CaseJurisdictionPredicateValidator.of(new CaseQueryContext(cb, qc.getQuery(), joins.getCaseJoins()), user)); + associatedJurisdictionValidators + .add(ContactJurisdictionPredicateValidator.of(new ContactQueryContext(cb, qc.getQuery(), joins.getContactJoins()), user)); associatedJurisdictionValidators .add(EventJurisdictionPredicateValidator.of(new EventQueryContext(cb, qc.getQuery(), joins.getEvent()), user)); diff --git a/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskService.java b/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskService.java index 745c3b349c79..190aa1319f1d 100644 --- a/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskService.java +++ b/sormas-backend/src/main/java/de/symeda/sormas/backend/task/TaskService.java @@ -161,8 +161,9 @@ public Predicate createUserFilterForJoin(TaskQueryContext taskQueryContext) { CriteriaQuery cq = taskQueryContext.getQuery(); CriteriaBuilder cb = taskQueryContext.getCriteriaBuilder(); From taskPath = taskQueryContext.getRoot(); + TaskJoins taskJoins = (TaskJoins) taskQueryContext.getJoins(); - Predicate assigneeFilter = createAssigneeFilter(cb, ((TaskJoins) taskQueryContext.getJoins()).getAssignee()); + Predicate assigneeFilter = createAssigneeFilter(cb, taskJoins.getAssignee()); final JurisdictionLevel jurisdictionLevel = currentUser.getJurisdictionLevel(); if ((jurisdictionLevel == JurisdictionLevel.NATION && !UserRole.isPortHealthUser(currentUser.getUserRoles())) @@ -173,19 +174,19 @@ public Predicate createUserFilterForJoin(TaskQueryContext taskQueryContext) { Predicate filter = cb.equal(taskPath.get(Task.CREATOR_USER), currentUser); filter = cb.or(filter, cb.equal(taskPath.get(Task.ASSIGNEE_USER), currentUser)); - Predicate caseFilter = caseService.createUserFilter(cb, cq, ((TaskJoins) taskQueryContext.getJoins()).getCaze()); + Predicate caseFilter = caseService.createUserFilter(cb, cq, taskJoins.getCaze()); if (caseFilter != null) { filter = cb.or(filter, caseFilter); } - Predicate contactFilter = contactService.createUserFilter(cb, cq, ((TaskJoins) taskQueryContext.getJoins()).getContact()); + Predicate contactFilter = contactService.createUserFilterForJoin(new ContactQueryContext(cb, cq, taskJoins.getContactJoins()), null); if (contactFilter != null) { filter = cb.or(filter, contactFilter); } - Predicate eventFilter = eventService.createUserFilter(cb, cq, ((TaskJoins) taskQueryContext.getJoins()).getEvent()); + Predicate eventFilter = eventService.createUserFilter(cb, cq, taskJoins.getEvent()); if (eventFilter != null) { filter = cb.or(filter, eventFilter); } - Predicate travelEntryFilter = travelEntryService.createUserFilter(cb, cq, ((TaskJoins) taskQueryContext.getJoins()).getTravelEntry()); + Predicate travelEntryFilter = travelEntryService.createUserFilter(cb, cq, taskJoins.getTravelEntry()); if (travelEntryFilter != null) { filter = cb.or(filter, travelEntryFilter); } @@ -551,23 +552,40 @@ public List> getJurisdictionSelections(TaskQueryContext qc) { CriteriaBuilder cb = qc.getCriteriaBuilder(); TaskJoins joins = (TaskJoins) qc.getJoins(); - ContactJoins contactJoins = new ContactJoins<>(joins.getContact()); + ContactJoins contactJoins = joins.getContactJoins(); return Arrays.asList( JurisdictionHelper.booleanSelector(cb, inJurisdictionOrOwned(qc)), JurisdictionHelper.booleanSelector( cb, - cb.and(cb.isNotNull(joins.getCaze()), caseService.inJurisdictionOrOwned(new CaseQueryContext(cb, qc.getQuery(), joins.getCaze())))), + cb.and( + cb.isNotNull(joins.getCaze()), + caseService.inJurisdictionOrOwned( + new CaseQueryContext( + cb, + qc.getQuery(), + joins + .getCaseJoins())))), JurisdictionHelper.booleanSelector( cb, cb.and( cb.isNotNull(joins.getContact()), - contactService.inJurisdictionOrOwned(new ContactQueryContext<>(cb, qc.getQuery(), joins.getContact())))), + contactService.inJurisdictionOrOwned( + new ContactQueryContext<>( + cb, + qc.getQuery(), + joins + .getContactJoins())))), JurisdictionHelper.booleanSelector( cb, cb.and( cb.isNotNull(joins.getContact()), - cb.isNotNull(contactJoins.getCaze()), - caseService.inJurisdictionOrOwned(new CaseQueryContext(cb, qc.getQuery(), contactJoins.getCaze())))), + cb.isNotNull(joins.getContactJoins().getCaze()), + caseService.inJurisdictionOrOwned( + new CaseQueryContext( + cb, + qc.getQuery(), + joins.getContactJoins() + .getCaseJoins())))), JurisdictionHelper.booleanSelector( cb, cb.and( diff --git a/sormas-backend/src/main/java/de/symeda/sormas/backend/util/AbstractDomainObjectJoins.java b/sormas-backend/src/main/java/de/symeda/sormas/backend/util/AbstractDomainObjectJoins.java index bbf2f03112e1..13f518504c16 100644 --- a/sormas-backend/src/main/java/de/symeda/sormas/backend/util/AbstractDomainObjectJoins.java +++ b/sormas-backend/src/main/java/de/symeda/sormas/backend/util/AbstractDomainObjectJoins.java @@ -1,6 +1,7 @@ package de.symeda.sormas.backend.util; import java.util.function.Consumer; +import java.util.function.Supplier; import javax.persistence.criteria.From; import javax.persistence.criteria.Join; @@ -35,4 +36,20 @@ protected Join getOrCreate(Join join, String attribute, JoinT return join; } + + protected > J getOrCreate( + J joins, + Supplier joinsSupplier, + Consumer setValue) { + + final J result; + if (joins == null) { + result = joinsSupplier.get(); + setValue.accept(result); + } else { + result = joins; + } + + return result; + } } diff --git a/sormas-backend/src/main/java/de/symeda/sormas/utils/CaseJoins.java b/sormas-backend/src/main/java/de/symeda/sormas/utils/CaseJoins.java index 8957e7615a6e..b850d663d587 100644 --- a/sormas-backend/src/main/java/de/symeda/sormas/utils/CaseJoins.java +++ b/sormas-backend/src/main/java/de/symeda/sormas/utils/CaseJoins.java @@ -35,6 +35,7 @@ import de.symeda.sormas.backend.infrastructure.region.Region; import de.symeda.sormas.backend.location.Location; import de.symeda.sormas.backend.person.Person; +import de.symeda.sormas.backend.person.PersonJoins; import de.symeda.sormas.backend.sample.Sample; import de.symeda.sormas.backend.share.ExternalShareInfo; import de.symeda.sormas.backend.sormastosormas.share.shareinfo.SormasToSormasShareInfo; @@ -76,6 +77,8 @@ public class CaseJoins extends AbstractDomainObjectJoins { private Join externalShareInfo; private Join followUpStatusChangeUser; + private PersonJoins personJoins; + public CaseJoins(From caze) { super(caze); } @@ -327,4 +330,12 @@ public Join getFollowUpStatusChangeUser() { private void setFollowUpStatusChangeUser(Join followUpStatusChangeUser) { this.followUpStatusChangeUser = followUpStatusChangeUser; } + + public PersonJoins getPersonJoins() { + return getOrCreate(personJoins, () -> new PersonJoins(getPerson()), this::setPersonJoins); + } + + private void setPersonJoins(PersonJoins personJoins) { + this.personJoins = personJoins; + } }