From 8245ff2557f967e7ac3bc88d0562b1d5e843634d Mon Sep 17 00:00:00 2001 From: Karthik Date: Fri, 22 Sep 2023 12:25:32 -0400 Subject: [PATCH 01/12] WIP --- .../persistence/ClinicalEventRepository.java | 4 + .../mybatis/ClinicalEventMapper.java | 3 + .../ClinicalEventMyBatisRepository.java | 7 ++ .../mybatis/ClinicalEventMapper.xml | 49 ++++++++++ .../ClinicalEventMyBatisRepositoryTest.java | 35 ++++++++ .../src/test/resources/testSql.sql | 4 + .../service/ClinicalEventService.java | 10 +++ .../impl/ClinicalEventServiceImpl.java | 72 +++++++++++++++ .../cbioportal/web/SurvivalController.java | 89 +++++++++++++++++++ .../web/parameter/ClinicalEventRequest.java | 33 +++++++ .../ClinicalEventRequestIdentifier.java | 31 +++++++ .../web/parameter/OccurrencePosition.java | 6 ++ .../web/parameter/SurvivalRequest.java | 53 +++++++++++ ...volvedCancerStudyExtractorInterceptor.java | 25 ++++++ 14 files changed, 421 insertions(+) create mode 100644 web/src/main/java/org/cbioportal/web/SurvivalController.java create mode 100644 web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequest.java create mode 100644 web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java create mode 100644 web/src/main/java/org/cbioportal/web/parameter/OccurrencePosition.java create mode 100644 web/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java diff --git a/persistence/persistence-api/src/main/java/org/cbioportal/persistence/ClinicalEventRepository.java b/persistence/persistence-api/src/main/java/org/cbioportal/persistence/ClinicalEventRepository.java index 74835374c94..cd994dd7a37 100644 --- a/persistence/persistence-api/src/main/java/org/cbioportal/persistence/ClinicalEventRepository.java +++ b/persistence/persistence-api/src/main/java/org/cbioportal/persistence/ClinicalEventRepository.java @@ -35,4 +35,8 @@ List getAllClinicalEventsInStudy(String studyId, String projectio @Cacheable(cacheResolver = "generalRepositoryCacheResolver", condition = "@cacheEnabledConfig.getEnabled()") List getPatientsDistinctClinicalEventInStudies(List studyIds, List patientIds); + + + @Cacheable(cacheResolver = "generalRepositoryCacheResolver", condition = "@cacheEnabledConfig.getEnabled()") + List getTimelineEvents(List studyIds, List patientIds, List clinicalEvents); } diff --git a/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMapper.java b/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMapper.java index 32da3ebc0e8..33799bb8466 100644 --- a/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMapper.java +++ b/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMapper.java @@ -23,4 +23,7 @@ List getStudyClinicalEvent(String studyId, String projection, Int List getSamplesOfPatientsPerEventType(List studyIds, List sampleIds); List getPatientsDistinctClinicalEventInStudies(List studyIds, List patientIds); + + List getTimelineEvents(List studyIds, List patientIds, List clinicalEvents); + } diff --git a/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepository.java b/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepository.java index 40ccc3c99b1..6a4d9e315b7 100644 --- a/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepository.java +++ b/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepository.java @@ -68,4 +68,11 @@ public Map> getSamplesOfPatientsPerEventTypeInStudy(List getPatientsDistinctClinicalEventInStudies(List studyIds, List patientIds) { return clinicalEventMapper.getPatientsDistinctClinicalEventInStudies(studyIds, patientIds); } + + @Override + public List getTimelineEvents(List studyIds, + List patientIds, + List clinicalEvents) { + return clinicalEventMapper.getTimelineEvents(studyIds, patientIds, clinicalEvents); + } } diff --git a/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml b/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml index 44f8083bf2e..bba636e0a52 100644 --- a/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml +++ b/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml @@ -184,4 +184,53 @@ Group by clinical_event.EVENT_TYPE, patient.STABLE_ID + diff --git a/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java b/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java index d44814115e9..9594dd93bb7 100644 --- a/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java +++ b/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java @@ -1,5 +1,7 @@ package org.cbioportal.persistence.mybatis; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; import org.cbioportal.model.ClinicalEvent; import org.cbioportal.model.ClinicalEventData; import org.cbioportal.model.meta.BaseMeta; @@ -219,4 +221,37 @@ public void getPatientsDistinctClinicalEventInStudies() { Assert.assertEquals(2, result.size()); Assert.assertTrue(eventTypes.contains("STATUS")); } + + @Test + public void getTimelineEvents() { + List studyList = new ArrayList<>(); + studyList.add("study_tcga_pub"); + List patientList = new ArrayList<>(); + patientList.add("TCGA-A1-A0SD"); + + ClinicalEventData clinicalEventData = new ClinicalEventData(); + clinicalEventData.setKey("AGENT"); + clinicalEventData.setValue("Madeupanib"); + + ClinicalEventData clinicalEventData2 = new ClinicalEventData(); + clinicalEventData2.setKey("AGENT"); + clinicalEventData2.setValue("abc"); + + ClinicalEvent requestClinicalEvent = new ClinicalEvent(); + requestClinicalEvent.setEventType("TREATMENT"); + requestClinicalEvent.setAttributes(Arrays.asList(clinicalEventData, clinicalEventData2)); + List result = clinicalEventMyBatisRepository.getTimelineEvents(studyList, patientList, Arrays.asList(requestClinicalEvent)); + + ObjectMapper mapper = new ObjectMapper(); + try { + System.out.println(mapper.writeValueAsString(result)); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } + + Assert.assertEquals("STATUS", "STATUS"); +// List eventTypes = result.stream().map(ClinicalEvent::getEventType).collect(Collectors.toList()); +// Assert.assertEquals(2, result.size()); +// Assert.assertTrue(eventTypes.contains("STATUS")); + } } diff --git a/persistence/persistence-mybatis/src/test/resources/testSql.sql b/persistence/persistence-mybatis/src/test/resources/testSql.sql index f7047bdbdf7..6f21428600f 100644 --- a/persistence/persistence-mybatis/src/test/resources/testSql.sql +++ b/persistence/persistence-mybatis/src/test/resources/testSql.sql @@ -458,6 +458,7 @@ INSERT INTO clinical_event (CLINICAL_EVENT_ID,PATIENT_ID,START_DATE,STOP_DATE,EV INSERT INTO clinical_event (CLINICAL_EVENT_ID,PATIENT_ID,START_DATE,STOP_DATE,EVENT_TYPE) VALUES (2,1,233,345,'SPECIMEN'); INSERT INTO clinical_event (CLINICAL_EVENT_ID,PATIENT_ID,START_DATE,STOP_DATE,EVENT_TYPE) VALUES (3,2,213,445,'TREATMENT'); INSERT INTO clinical_event (CLINICAL_EVENT_ID,PATIENT_ID,START_DATE,STOP_DATE,EVENT_TYPE) VALUES (4,2,211,441,'SEQENCING'); +INSERT INTO clinical_event (CLINICAL_EVENT_ID,PATIENT_ID,START_DATE,STOP_DATE,EVENT_TYPE) VALUES (5,2,313,543,'TREATMENT'); INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (1,'STATUS','radiographic_progression'); INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (1,'SAMPLE_ID','TCGA-A1-A0SB-01'); @@ -468,6 +469,9 @@ INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (3,'AGENT', INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (3,'AGENT_TARGET','Directly to forehead, Elbow'); INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (3,'SAMPLE_ID','TCGA-A1-A0SD-01'); INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (4,'SAMPLE_ID','TCGA-A1-A0SD-01'); +INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (5,'EVENT_TYPE_DETAILED','AA III Recurrence1'); +INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (5,'AGENT','abc'); +INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (5,'AGENT_TARGET','Directly to forehead, Elbow'); INSERT INTO geneset (ID,GENETIC_ENTITY_ID,EXTERNAL_ID,NAME,DESCRIPTION,REF_LINK) VALUES (1,17,'MORF_ATRX','MORF ATRX name','Morf description','https://morf_link'); INSERT INTO geneset (ID,GENETIC_ENTITY_ID,EXTERNAL_ID,NAME,DESCRIPTION,REF_LINK) VALUES (2,18,'HINATA_NFKB_MATRIX','HINATA NFKB MATRIX name','Hinata description','https://hinata_link'); diff --git a/service/src/main/java/org/cbioportal/service/ClinicalEventService.java b/service/src/main/java/org/cbioportal/service/ClinicalEventService.java index a1b0a5c7ae6..658556cd15a 100644 --- a/service/src/main/java/org/cbioportal/service/ClinicalEventService.java +++ b/service/src/main/java/org/cbioportal/service/ClinicalEventService.java @@ -1,6 +1,8 @@ package org.cbioportal.service; +import org.cbioportal.model.ClinicalData; import org.cbioportal.model.ClinicalEvent; +import org.cbioportal.model.ClinicalEventData; import org.cbioportal.model.ClinicalEventTypeCount; import org.cbioportal.model.meta.BaseMeta; import org.cbioportal.service.exception.PatientNotFoundException; @@ -9,6 +11,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.function.Function; public interface ClinicalEventService { @@ -29,4 +32,11 @@ BaseMeta getMetaClinicalEvents(String studyId) Map> getPatientsSamplesPerClinicalEventType(List studyIds, List sampleIds); List getClinicalEventTypeCounts(List studyIds, List sampleIds); + + List getSurvivalData(List studyIds, List patientIds, + String attributeIdPrefix, + List startClinicalEventsMeta, + Function startPositionIdentifier, + List endClinicalEventsMeta, + Function endPositionIdentifier); } diff --git a/service/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java b/service/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java index 7cb3f304bdb..3a614ab4aeb 100644 --- a/service/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java +++ b/service/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java @@ -1,5 +1,6 @@ package org.cbioportal.service.impl; +import org.apache.commons.collections4.CollectionUtils; import org.cbioportal.model.*; import org.cbioportal.model.meta.BaseMeta; import org.cbioportal.persistence.ClinicalEventRepository; @@ -11,7 +12,9 @@ import org.springframework.stereotype.Service; import java.util.*; +import java.util.function.Function; import java.util.stream.Collectors; +import java.util.stream.Stream; @Service public class ClinicalEventServiceImpl implements ClinicalEventService { @@ -108,4 +111,73 @@ public List getClinicalEventTypeCounts(List stud .map(e -> new ClinicalEventTypeCount(e.getKey(),e.getValue())) .collect(Collectors.toList()); } + + @Override + public List getSurvivalData(List studyIds, + List patientIds, + String attributeIdPrefix, + List startClinicalEventsMeta, + Function startPositionIdentifier, + List endClinicalEventsMeta, + Function endPositionIdentifier) { + + List patientStartEvents = clinicalEventRepository.getTimelineEvents(studyIds, patientIds, startClinicalEventsMeta); + + List filteredStudyIds = new ArrayList<>(); + List filteredPatientIds = new ArrayList<>(); + for (ClinicalEvent clinicalEvent : patientStartEvents) { + filteredStudyIds.add(clinicalEvent.getStudyId()); + filteredPatientIds.add(clinicalEvent.getPatientId()); + } + List patientEndEvents = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(endClinicalEventsMeta) && CollectionUtils.isNotEmpty(filteredStudyIds)) { + patientEndEvents = clinicalEventRepository.getTimelineEvents(filteredStudyIds, filteredPatientIds, endClinicalEventsMeta); + } + + Map patientEndEventsById = patientEndEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); + + filteredStudyIds.clear(); + filteredPatientIds.clear(); + for (ClinicalEvent clinicalEvent : patientStartEvents.stream().filter(x -> !patientEndEventsById.containsKey(getKey(x))).collect(Collectors.toList())) { + filteredStudyIds.add(clinicalEvent.getStudyId()); + filteredPatientIds.add(clinicalEvent.getPatientId()); + } + + List patientLastEvents = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(filteredStudyIds)) { + patientLastEvents = clinicalEventRepository.getTimelineEvents(filteredStudyIds, filteredPatientIds, new ArrayList<>()); + } + + Map patientLastEventsById = patientLastEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); + + return patientStartEvents.stream() + .flatMap(x -> { + ClinicalData clinicalDataMonths = new ClinicalData(); + clinicalDataMonths.setStudyId(x.getStudyId()); + clinicalDataMonths.setPatientId(x.getPatientId()); + clinicalDataMonths.setAttrId(attributeIdPrefix+"_MONTHS"); + + ClinicalData clinicalDataStatus = new ClinicalData(); + clinicalDataStatus.setStudyId(x.getStudyId()); + clinicalDataStatus.setPatientId(x.getPatientId()); + clinicalDataStatus.setAttrId(attributeIdPrefix+"_STATUS"); + + Integer startDate = startPositionIdentifier.apply(x); + Integer endDate; + if (patientEndEventsById.containsKey(getKey(x))) { + clinicalDataStatus.setAttrValue("1:EVENT"); + endDate = endPositionIdentifier.apply(patientEndEventsById.get(getKey(x))); + } else { + clinicalDataStatus.setAttrValue("0:CENSORED"); + endDate = endPositionIdentifier.apply(patientLastEventsById.get(getKey(x))); + } + clinicalDataMonths.setAttrValue(String.valueOf((endDate - startDate) / 30.4)); + + return Stream.of(clinicalDataMonths, clinicalDataStatus); + }).collect(Collectors.toList()); + } + + private static String getKey(ClinicalEvent clinicalEvent) { + return clinicalEvent.getStudyId() + clinicalEvent.getPatientId(); + } } diff --git a/web/src/main/java/org/cbioportal/web/SurvivalController.java b/web/src/main/java/org/cbioportal/web/SurvivalController.java new file mode 100644 index 00000000000..5b22e5a020c --- /dev/null +++ b/web/src/main/java/org/cbioportal/web/SurvivalController.java @@ -0,0 +1,89 @@ +package org.cbioportal.web; + +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; +import org.cbioportal.model.ClinicalData; +import org.cbioportal.model.ClinicalEvent; +import org.cbioportal.service.ClinicalEventService; +import org.cbioportal.web.config.annotation.InternalApi; +import org.cbioportal.web.parameter.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; +import springfox.documentation.annotations.ApiIgnore; + +import javax.validation.Valid; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.function.Function; +import java.util.stream.Collectors; + +@InternalApi +@RestController +@Validated +@Api(tags = "Survival", description = " ") +public class SurvivalController { + + @Autowired + private ClinicalEventService clinicalEventService; + + @PreAuthorize("hasPermission(#involvedCancerStudies, 'Collection', T(org.cbioportal.utils.security.AccessLevel).READ)") + @RequestMapping(value = "/survival-data/fetch", + method = RequestMethod.POST, + consumes = MediaType.APPLICATION_JSON_VALUE, + produces = MediaType.APPLICATION_JSON_VALUE) + @ApiOperation("Fetch survival data") + public ResponseEntity> fetchSurvivalData( + @ApiParam(required = true, value = "Survival Data Request") + @Valid @RequestBody(required = false) SurvivalRequest survivalRequest, + @ApiIgnore // prevent reference to this attribute in the swagger-ui interface + @RequestAttribute(required = false, value = "involvedCancerStudies") Collection involvedCancerStudies, + @ApiIgnore + // prevent reference to this attribute in the swagger-ui interface. this attribute is needed for the @PreAuthorize tag above. + @Valid @RequestAttribute(required = false, value = "interceptedSurvivalRequest") SurvivalRequest interceptedSurvivalRequest) { + + List studyIds = new ArrayList<>(); + List patientIds = new ArrayList<>(); + for (PatientIdentifier patientIdentifier : interceptedSurvivalRequest.getPatientIdentifiers()) { + studyIds.add(patientIdentifier.getStudyId()); + patientIds.add(patientIdentifier.getPatientId()); + } + + List endClinicalEventsMeta = null; + Function endPositionIdentifier = ClinicalEvent::getStopDate; + if(interceptedSurvivalRequest.getEndEventRequestIdentifier() != null) { + endClinicalEventsMeta = getToClinicalEvents(interceptedSurvivalRequest.getEndEventRequestIdentifier()); + endPositionIdentifier = getPositionIdentifier(interceptedSurvivalRequest.getEndEventRequestIdentifier().getPosition()); + } + + List result = clinicalEventService.getSurvivalData(studyIds, + patientIds, + "", + getToClinicalEvents(interceptedSurvivalRequest.getStartEventRequestIdentifier()), + getPositionIdentifier(interceptedSurvivalRequest.getStartEventRequestIdentifier().getPosition()), + endClinicalEventsMeta, + endPositionIdentifier); + + return new ResponseEntity<>(result, HttpStatus.OK); + } + + private static List getToClinicalEvents(ClinicalEventRequestIdentifier clinicalEventRequestIdentifier) { + return clinicalEventRequestIdentifier.getClinicalEventRequests().stream().map(x -> { + ClinicalEvent clinicalEvent = new ClinicalEvent(); + clinicalEvent.setEventType(x.getEventType()); + clinicalEvent.setAttributes(x.getAttributes()); + + return clinicalEvent; + }).collect(Collectors.toList()); + } + + private static Function getPositionIdentifier(OccurrencePosition position) { + return position.equals(OccurrencePosition.FIRST) ? ClinicalEvent::getStartDate : ClinicalEvent::getStopDate; + } +} diff --git a/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequest.java b/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequest.java new file mode 100644 index 00000000000..468c5e68658 --- /dev/null +++ b/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequest.java @@ -0,0 +1,33 @@ +package org.cbioportal.web.parameter; + +import org.cbioportal.model.ClinicalEventData; + +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import java.io.Serializable; +import java.util.List; + +public class ClinicalEventRequest implements Serializable { + + @NotNull + private String eventType; + + @Size(min = 1, max = PagingConstants.MAX_PAGE_SIZE) + private List attributes; + + public String getEventType() { + return eventType; + } + + public void setEventType(String eventType) { + this.eventType = eventType; + } + + public List getAttributes() { + return attributes; + } + + public void setAttributes(List attributes) { + this.attributes = attributes; + } +} diff --git a/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java b/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java new file mode 100644 index 00000000000..3c801b1ae6f --- /dev/null +++ b/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java @@ -0,0 +1,31 @@ +package org.cbioportal.web.parameter; + + +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import java.io.Serializable; +import java.util.Set; + +public class ClinicalEventRequestIdentifier implements Serializable { + + @Size(min = 1, max = PagingConstants.MAX_PAGE_SIZE) + Set clinicalEventRequests; + @NotNull + OccurrencePosition position; + + public Set getClinicalEventRequests() { + return clinicalEventRequests; + } + + public void setClinicalEventRequests(Set clinicalEventRequests) { + this.clinicalEventRequests = clinicalEventRequests; + } + + public OccurrencePosition getPosition() { + return position; + } + + public void setPosition(OccurrencePosition position) { + this.position = position; + } +} diff --git a/web/src/main/java/org/cbioportal/web/parameter/OccurrencePosition.java b/web/src/main/java/org/cbioportal/web/parameter/OccurrencePosition.java new file mode 100644 index 00000000000..b9a5dbc9aad --- /dev/null +++ b/web/src/main/java/org/cbioportal/web/parameter/OccurrencePosition.java @@ -0,0 +1,6 @@ +package org.cbioportal.web.parameter; + +public enum OccurrencePosition { + FIRST, + LAST +} diff --git a/web/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java b/web/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java new file mode 100644 index 00000000000..3b9ff083734 --- /dev/null +++ b/web/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java @@ -0,0 +1,53 @@ +package org.cbioportal.web.parameter; + +import javax.validation.Valid; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import java.io.Serializable; +import java.util.List; + +public class SurvivalRequest implements Serializable { + + @Size(min = 1, max = PagingConstants.MAX_PAGE_SIZE) + private List patientIdentifiers; + + @NotNull + private String attributeIdPrefix; + + @Valid + private ClinicalEventRequestIdentifier startEventRequestIdentifier; + + private ClinicalEventRequestIdentifier endEventRequestIdentifier; + + public List getPatientIdentifiers() { + return patientIdentifiers; + } + + public void setPatientIdentifiers(List patientIdentifiers) { + this.patientIdentifiers = patientIdentifiers; + } + + public String getAttributeIdPrefix() { + return attributeIdPrefix; + } + + public void setAttributeIdPrefix(String attributeIdPrefix) { + this.attributeIdPrefix = attributeIdPrefix; + } + + public ClinicalEventRequestIdentifier getStartEventRequestIdentifier() { + return startEventRequestIdentifier; + } + + public void setStartEventRequestIdentifier(ClinicalEventRequestIdentifier startEventRequestIdentifier) { + this.startEventRequestIdentifier = startEventRequestIdentifier; + } + + public ClinicalEventRequestIdentifier getEndEventRequestIdentifier() { + return endEventRequestIdentifier; + } + + public void setEndEventRequestIdentifier(ClinicalEventRequestIdentifier endEventRequestIdentifier) { + this.endEventRequestIdentifier = endEventRequestIdentifier; + } +} diff --git a/web/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java b/web/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java index 91720ee1f81..8d24b47a1e9 100644 --- a/web/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java +++ b/web/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java @@ -105,6 +105,7 @@ public class InvolvedCancerStudyExtractorInterceptor extends HandlerInterceptorA public static final String GENERIC_ASSAY_CATEGORICAL_ENRICHMENT_FETCH_PATH = "/generic-assay-categorical-enrichments/fetch"; public static final String GENERIC_ASSAY_BINARY_ENRICHMENT_FETCH_PATH = "/generic-assay-binary-enrichments/fetch"; public static final String CLINICAL_EVENT_TYPE_COUNT_FETCH_PATH = "/clinical-event-type-counts/fetch"; + public static final String SURVIVAL_DATA_FETCH_PATH = "/survival-data/fetch"; @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (!request.getMethod().equals("POST")) { @@ -163,6 +164,8 @@ public class InvolvedCancerStudyExtractorInterceptor extends HandlerInterceptorA return extractAttributesFromStructuralVariantFilter(request); } else if (requestPathInfo.equals(GENERIC_ASSAY_DATA_MULTIPLE_STUDY_FETCH_PATH)) { return extractAttributesFromGenericAssayDataMultipleStudyFilter(request); + } else if (requestPathInfo.equals(SURVIVAL_DATA_FETCH_PATH)) { + return extractCancerStudyIdsFromSurvivalRequest(request); } return true; } @@ -801,4 +804,26 @@ private Set extractCancerStudyIdsFromMolecularProfileCasesGroups(Collect return studyIdSet; } + private boolean extractCancerStudyIdsFromSurvivalRequest(HttpServletRequest request) { + try { + SurvivalRequest survivalRequest = objectMapper.readValue(request.getInputStream(), SurvivalRequest.class); + LOG.debug("extracted survivalRequest: " + survivalRequest.toString()); + LOG.debug("setting interceptedSurvivalRequest to " + survivalRequest); + request.setAttribute("interceptedSurvivalRequest", survivalRequest); + if (cacheMapUtil.hasCacheEnabled()) { + Collection cancerStudyIdCollection = survivalRequest + .getPatientIdentifiers() + .stream() + .map(PatientIdentifier::getStudyId) + .collect(Collectors.toSet()); + LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); + } + } catch (Exception e) { + LOG.error("exception thrown during extraction of genericAssayDataMultipleStudyFilter: " + e); + return false; + } + return true; + } + } From a534091412e069b721e4c2c17534592e6f99afd9 Mon Sep 17 00:00:00 2001 From: Karthik Date: Mon, 25 Sep 2023 19:59:38 -0400 Subject: [PATCH 02/12] WIP --- .../persistence/mybatis/ClinicalEventMapper.xml | 16 +++++++++++----- .../ClinicalEventMyBatisRepositoryTest.java | 10 +++++----- .../org/cbioportal/web/SurvivalController.java | 2 +- .../web/parameter/ClinicalEventRequest.java | 1 - .../web/parameter/SurvivalRequest.java | 1 + 5 files changed, 18 insertions(+), 12 deletions(-) diff --git a/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml b/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml index bba636e0a52..8008e718683 100644 --- a/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml +++ b/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml @@ -223,11 +223,17 @@ - AND (clinical_event.EVENT_TYPE, clinical_event_data.KEY, clinical_event_data.VALUE) IN - - - (#{element.eventType}, #{attribute.key}, #{attribute.value}) - + AND + + + clinical_event.EVENT_TYPE = #{element.eventType} + + + (clinical_event.EVENT_TYPE, clinical_event_data.KEY, clinical_event_data.VALUE) IN + + (#{element.eventType}, #{attribute.key}, #{attribute.value}) + + GROUP BY diff --git a/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java b/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java index 9594dd93bb7..d67bf4bd74e 100644 --- a/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java +++ b/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java @@ -132,7 +132,7 @@ public void getAllClinicalEventsInStudyIdProjection() throws Exception { List result = clinicalEventMyBatisRepository.getAllClinicalEventsInStudy( "study_tcga_pub", "ID", null, null, null, null); - Assert.assertEquals(4, result.size()); + Assert.assertEquals(5, result.size()); ClinicalEvent clinicalEvent = result.get(0); Assert.assertEquals((Integer) 2, clinicalEvent.getClinicalEventId()); Assert.assertEquals("study_tcga_pub", clinicalEvent.getStudyId()); @@ -145,7 +145,7 @@ public void getAllClinicalEventsInStudySummaryProjection() throws Exception { List result = clinicalEventMyBatisRepository.getAllClinicalEventsInStudy( "study_tcga_pub", "SUMMARY", null, null, null, null); - Assert.assertEquals(4, result.size()); + Assert.assertEquals(5, result.size()); ClinicalEvent clinicalEvent = result.get(0); Assert.assertEquals((Integer) 2, clinicalEvent.getClinicalEventId()); Assert.assertEquals("study_tcga_pub", clinicalEvent.getStudyId()); @@ -160,7 +160,7 @@ public void getAllClinicalEventsInStudyDetailedProjection() throws Exception { List result = clinicalEventMyBatisRepository.getAllClinicalEventsInStudy( "study_tcga_pub", "DETAILED", null, null, null, null); - Assert.assertEquals(4, result.size()); + Assert.assertEquals(5, result.size()); ClinicalEvent clinicalEvent = result.get(0); Assert.assertEquals((Integer) 2, clinicalEvent.getClinicalEventId()); Assert.assertEquals("study_tcga_pub", clinicalEvent.getStudyId()); @@ -184,7 +184,7 @@ public void getAllClinicalEventsInStudySummaryProjectionEventTypeSort() throws E List result = clinicalEventMyBatisRepository.getAllClinicalEventsInStudy( "study_tcga_pub", "SUMMARY", null, null, "eventType", "ASC"); - Assert.assertEquals(4, result.size()); + Assert.assertEquals(5, result.size()); Assert.assertEquals("SPECIMEN", result.get(1).getEventType()); Assert.assertEquals("STATUS", result.get(2).getEventType()); } @@ -194,7 +194,7 @@ public void getMetaClinicalEvents() throws Exception { BaseMeta result = clinicalEventMyBatisRepository.getMetaClinicalEvents("study_tcga_pub"); - Assert.assertEquals((Integer) 4, result.getTotalCount()); + Assert.assertEquals((Integer) 5, result.getTotalCount()); } @Test diff --git a/web/src/main/java/org/cbioportal/web/SurvivalController.java b/web/src/main/java/org/cbioportal/web/SurvivalController.java index 5b22e5a020c..93ec040ab07 100644 --- a/web/src/main/java/org/cbioportal/web/SurvivalController.java +++ b/web/src/main/java/org/cbioportal/web/SurvivalController.java @@ -64,7 +64,7 @@ public ResponseEntity> fetchSurvivalData( List result = clinicalEventService.getSurvivalData(studyIds, patientIds, - "", + interceptedSurvivalRequest.getAttributeIdPrefix(), getToClinicalEvents(interceptedSurvivalRequest.getStartEventRequestIdentifier()), getPositionIdentifier(interceptedSurvivalRequest.getStartEventRequestIdentifier().getPosition()), endClinicalEventsMeta, diff --git a/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequest.java b/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequest.java index 468c5e68658..5d4586e3799 100644 --- a/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequest.java +++ b/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequest.java @@ -12,7 +12,6 @@ public class ClinicalEventRequest implements Serializable { @NotNull private String eventType; - @Size(min = 1, max = PagingConstants.MAX_PAGE_SIZE) private List attributes; public String getEventType() { diff --git a/web/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java b/web/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java index 3b9ff083734..cf10cdd2045 100644 --- a/web/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java +++ b/web/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java @@ -17,6 +17,7 @@ public class SurvivalRequest implements Serializable { @Valid private ClinicalEventRequestIdentifier startEventRequestIdentifier; + @Valid private ClinicalEventRequestIdentifier endEventRequestIdentifier; public List getPatientIdentifiers() { From 6312d7ed650ff23e6599a7508b6704e836748954 Mon Sep 17 00:00:00 2001 From: Karthik Date: Tue, 3 Oct 2023 11:19:58 -0400 Subject: [PATCH 03/12] WIP --- .../persistence/ClinicalEventRepository.java | 3 + .../mybatis/ClinicalEventMapper.java | 1 + .../ClinicalEventMyBatisRepository.java | 5 ++ .../mybatis/ClinicalEventMapper.xml | 90 ++++++++++++++++--- .../ClinicalEventMyBatisRepositoryTest.java | 34 +++++++ .../src/test/resources/logback.xml | 3 + .../service/ClinicalEventService.java | 3 + .../impl/ClinicalEventServiceImpl.java | 5 ++ .../web/ClinicalEventController.java | 54 +++++++++-- .../ClinicalEventAttributeRequest.java | 30 +++++++ ...volvedCancerStudyExtractorInterceptor.java | 25 ++++++ 11 files changed, 230 insertions(+), 23 deletions(-) create mode 100644 web/src/main/java/org/cbioportal/web/parameter/ClinicalEventAttributeRequest.java diff --git a/persistence/persistence-api/src/main/java/org/cbioportal/persistence/ClinicalEventRepository.java b/persistence/persistence-api/src/main/java/org/cbioportal/persistence/ClinicalEventRepository.java index cd994dd7a37..bf6d31470c9 100644 --- a/persistence/persistence-api/src/main/java/org/cbioportal/persistence/ClinicalEventRepository.java +++ b/persistence/persistence-api/src/main/java/org/cbioportal/persistence/ClinicalEventRepository.java @@ -39,4 +39,7 @@ List getAllClinicalEventsInStudy(String studyId, String projectio @Cacheable(cacheResolver = "generalRepositoryCacheResolver", condition = "@cacheEnabledConfig.getEnabled()") List getTimelineEvents(List studyIds, List patientIds, List clinicalEvents); + + @Cacheable(cacheResolver = "generalRepositoryCacheResolver", condition = "@cacheEnabledConfig.getEnabled()") + List getClinicalEventsMeta(List studyIds, List patientIds, List clinicalEvents); } diff --git a/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMapper.java b/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMapper.java index 33799bb8466..d87b0e8467d 100644 --- a/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMapper.java +++ b/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMapper.java @@ -26,4 +26,5 @@ List getStudyClinicalEvent(String studyId, String projection, Int List getTimelineEvents(List studyIds, List patientIds, List clinicalEvents); + List getClinicalEventsMeta(List studyIds, List patientIds, List clinicalEvents); } diff --git a/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepository.java b/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepository.java index 6a4d9e315b7..b169ce8e68e 100644 --- a/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepository.java +++ b/persistence/persistence-mybatis/src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepository.java @@ -75,4 +75,9 @@ public List getTimelineEvents(List studyIds, List clinicalEvents) { return clinicalEventMapper.getTimelineEvents(studyIds, patientIds, clinicalEvents); } + + @Override + public List getClinicalEventsMeta(List studyIds, List patientIds, List clinicalEvents) { + return clinicalEventMapper.getClinicalEventsMeta(studyIds, patientIds, clinicalEvents); + } } diff --git a/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml b/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml index 8008e718683..69e3c42d901 100644 --- a/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml +++ b/persistence/persistence-mybatis/src/main/resources/org/cbioportal/persistence/mybatis/ClinicalEventMapper.xml @@ -221,22 +221,84 @@ + + AND + + + clinical_event.EVENT_TYPE = #{element.eventType} + + + (clinical_event.EVENT_TYPE, clinical_event_data.KEY, clinical_event_data.VALUE) IN + + (#{element.eventType}, #{attribute.key}, #{attribute.value}) + + + + - - AND - - - clinical_event.EVENT_TYPE = #{element.eventType} - - - (clinical_event.EVENT_TYPE, clinical_event_data.KEY, clinical_event_data.VALUE) IN - - (#{element.eventType}, #{attribute.key}, #{attribute.value}) - - - - GROUP BY clinical_event.PATIENT_ID, cancer_study.CANCER_STUDY_IDENTIFIER; + + + + + + + + + + diff --git a/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java b/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java index d67bf4bd74e..48b5b72d7fe 100644 --- a/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java +++ b/persistence/persistence-mybatis/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java @@ -252,6 +252,40 @@ public void getTimelineEvents() { Assert.assertEquals("STATUS", "STATUS"); // List eventTypes = result.stream().map(ClinicalEvent::getEventType).collect(Collectors.toList()); // Assert.assertEquals(2, result.size()); +// Assert.assertTrue(eventTypes.contains("STATUS")); + } + + + @Test + public void getClinicalEventsMeta() { + List studyList = new ArrayList<>(); + studyList.add("study_tcga_pub"); + List patientList = new ArrayList<>(); + patientList.add("TCGA-A1-A0SD"); + + ClinicalEventData clinicalEventData = new ClinicalEventData(); + clinicalEventData.setKey("AGENT"); + clinicalEventData.setValue("Madeupanib"); + + ClinicalEventData clinicalEventData2 = new ClinicalEventData(); + clinicalEventData2.setKey("AGENT"); + clinicalEventData2.setValue("abc"); + + ClinicalEvent requestClinicalEvent = new ClinicalEvent(); + requestClinicalEvent.setEventType("TREATMENT"); + requestClinicalEvent.setAttributes(Arrays.asList(clinicalEventData, clinicalEventData2)); + List result = clinicalEventMyBatisRepository.getClinicalEventsMeta(studyList, patientList, Arrays.asList(requestClinicalEvent)); + + ObjectMapper mapper = new ObjectMapper(); + try { + System.out.println(mapper.writeValueAsString(result)); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } + + Assert.assertEquals("STATUS", "STATUS"); +// List eventTypes = result.stream().map(ClinicalEvent::getEventType).collect(Collectors.toList()); +// Assert.assertEquals(2, result.size()); // Assert.assertTrue(eventTypes.contains("STATUS")); } } diff --git a/persistence/persistence-mybatis/src/test/resources/logback.xml b/persistence/persistence-mybatis/src/test/resources/logback.xml index 9d21a927c45..b9e08aba003 100644 --- a/persistence/persistence-mybatis/src/test/resources/logback.xml +++ b/persistence/persistence-mybatis/src/test/resources/logback.xml @@ -16,6 +16,9 @@ --> + + + diff --git a/service/src/main/java/org/cbioportal/service/ClinicalEventService.java b/service/src/main/java/org/cbioportal/service/ClinicalEventService.java index 658556cd15a..68239585b07 100644 --- a/service/src/main/java/org/cbioportal/service/ClinicalEventService.java +++ b/service/src/main/java/org/cbioportal/service/ClinicalEventService.java @@ -39,4 +39,7 @@ List getSurvivalData(List studyIds, List patientId Function startPositionIdentifier, List endClinicalEventsMeta, Function endPositionIdentifier); + + List getClinicalEventsMeta(List studyIds, List patientIds, + List clinicalEvents); } diff --git a/service/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java b/service/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java index 3a614ab4aeb..8fca6a37b22 100644 --- a/service/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java +++ b/service/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java @@ -177,6 +177,11 @@ public List getSurvivalData(List studyIds, }).collect(Collectors.toList()); } + @Override + public List getClinicalEventsMeta(List studyIds, List patientIds, List clinicalEvents) { + return clinicalEventRepository.getClinicalEventsMeta(studyIds, patientIds, clinicalEvents); + } + private static String getKey(ClinicalEvent clinicalEvent) { return clinicalEvent.getStudyId() + clinicalEvent.getPatientId(); } diff --git a/web/src/main/java/org/cbioportal/web/ClinicalEventController.java b/web/src/main/java/org/cbioportal/web/ClinicalEventController.java index e9b07cae95a..4c12e2d7973 100644 --- a/web/src/main/java/org/cbioportal/web/ClinicalEventController.java +++ b/web/src/main/java/org/cbioportal/web/ClinicalEventController.java @@ -9,10 +9,7 @@ import org.cbioportal.service.exception.StudyNotFoundException; import org.cbioportal.web.config.InternalApiTags; import org.cbioportal.web.config.annotation.InternalApi; -import org.cbioportal.web.parameter.Direction; -import org.cbioportal.web.parameter.HeaderKeyConstants; -import org.cbioportal.web.parameter.PagingConstants; -import org.cbioportal.web.parameter.Projection; +import org.cbioportal.web.parameter.*; import org.cbioportal.web.parameter.sort.ClinicalEventSortBy; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpHeaders; @@ -20,16 +17,18 @@ import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.validation.annotation.Validated; -import org.springframework.web.bind.annotation.PathVariable; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestMethod; -import org.springframework.web.bind.annotation.RequestParam; -import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.bind.annotation.*; import org.springframework.security.access.prepost.PreAuthorize; +import springfox.documentation.annotations.ApiIgnore; +import javax.validation.Valid; import javax.validation.constraints.Max; import javax.validation.constraints.Min; +import java.util.ArrayList; +import java.util.Collection; import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; @InternalApi @RestController @@ -111,4 +110,41 @@ public ResponseEntity> getAllClinicalEventsInStudy( sortBy == null ? null : sortBy.getOriginalValue(), direction.name()), HttpStatus.OK); } } + + @PreAuthorize("hasPermission(#involvedCancerStudies, 'Collection', T(org.cbioportal.utils.security.AccessLevel).READ)") + @RequestMapping(value = "/clinical-events-meta/fetch", + method = RequestMethod.POST, + consumes = MediaType.APPLICATION_JSON_VALUE, + produces = MediaType.APPLICATION_JSON_VALUE) + @ApiOperation("Fetch clinical events meta") + public ResponseEntity> fetchClinicalEventsMeta( + @ApiParam(required = true, value = "clinical events Request") + @Valid @RequestBody(required = false) ClinicalEventAttributeRequest clinicalEventAttributeRequest, + @ApiIgnore // prevent reference to this attribute in the swagger-ui interface + @RequestAttribute(required = false, value = "involvedCancerStudies") Collection involvedCancerStudies, + @ApiIgnore + // prevent reference to this attribute in the swagger-ui interface. this attribute is needed for the @PreAuthorize tag above. + @Valid @RequestAttribute(required = false, value = "interceptedClinicalEventAttributeRequest") ClinicalEventAttributeRequest interceptedClinicalEventAttributeRequest) { + + List studyIds = new ArrayList<>(); + List patientIds = new ArrayList<>(); + for (PatientIdentifier patientIdentifier : interceptedClinicalEventAttributeRequest.getPatientIdentifiers()) { + studyIds.add(patientIdentifier.getStudyId()); + patientIds.add(patientIdentifier.getPatientId()); + } + + List clinicalEventsRequest = interceptedClinicalEventAttributeRequest.getClinicalEventRequests() + .stream() + .map(x -> { + ClinicalEvent clinicalEvent = new ClinicalEvent(); + clinicalEvent.setEventType(x.getEventType()); + clinicalEvent.setAttributes(x.getAttributes()); + return clinicalEvent; + }) + .collect(Collectors.toList()); + + return new ResponseEntity<>(clinicalEventService.getClinicalEventsMeta( + studyIds, patientIds, clinicalEventsRequest), HttpStatus.OK); + + } } diff --git a/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventAttributeRequest.java b/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventAttributeRequest.java new file mode 100644 index 00000000000..39c6ffefac7 --- /dev/null +++ b/web/src/main/java/org/cbioportal/web/parameter/ClinicalEventAttributeRequest.java @@ -0,0 +1,30 @@ +package org.cbioportal.web.parameter; + +import javax.validation.constraints.Size; +import java.io.Serializable; +import java.util.List; +import java.util.Set; + +public class ClinicalEventAttributeRequest implements Serializable { + + @Size(min = 1, max = PagingConstants.MAX_PAGE_SIZE) + private List patientIdentifiers; + + Set clinicalEventRequests; + + public List getPatientIdentifiers() { + return patientIdentifiers; + } + + public void setPatientIdentifiers(List patientIdentifiers) { + this.patientIdentifiers = patientIdentifiers; + } + + public Set getClinicalEventRequests() { + return clinicalEventRequests; + } + + public void setClinicalEventRequests(Set clinicalEventRequests) { + this.clinicalEventRequests = clinicalEventRequests; + } +} diff --git a/web/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java b/web/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java index 8d24b47a1e9..e20bff1f358 100644 --- a/web/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java +++ b/web/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java @@ -106,6 +106,7 @@ public class InvolvedCancerStudyExtractorInterceptor extends HandlerInterceptorA public static final String GENERIC_ASSAY_BINARY_ENRICHMENT_FETCH_PATH = "/generic-assay-binary-enrichments/fetch"; public static final String CLINICAL_EVENT_TYPE_COUNT_FETCH_PATH = "/clinical-event-type-counts/fetch"; public static final String SURVIVAL_DATA_FETCH_PATH = "/survival-data/fetch"; + public static final String CLINICAL_EVENT_META_FETCH_PATH = "/clinical-events-meta/fetch"; @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (!request.getMethod().equals("POST")) { @@ -166,6 +167,8 @@ public class InvolvedCancerStudyExtractorInterceptor extends HandlerInterceptorA return extractAttributesFromGenericAssayDataMultipleStudyFilter(request); } else if (requestPathInfo.equals(SURVIVAL_DATA_FETCH_PATH)) { return extractCancerStudyIdsFromSurvivalRequest(request); + } else if (requestPathInfo.equals(CLINICAL_EVENT_META_FETCH_PATH)) { + return extractCancerStudyIdsFromClinicalEventAttributeRequest(request); } return true; } @@ -826,4 +829,26 @@ private boolean extractCancerStudyIdsFromSurvivalRequest(HttpServletRequest requ return true; } + private boolean extractCancerStudyIdsFromClinicalEventAttributeRequest(HttpServletRequest request) { + try { + ClinicalEventAttributeRequest clinicalEventAttributeRequest = objectMapper.readValue(request.getInputStream(), ClinicalEventAttributeRequest.class); + LOG.debug("extracted clinicalEventAttributeRequest: " + clinicalEventAttributeRequest.toString()); + LOG.debug("setting interceptedClinicalEventAttributeRequest to " + clinicalEventAttributeRequest); + request.setAttribute("interceptedClinicalEventAttributeRequest", clinicalEventAttributeRequest); + if (cacheMapUtil.hasCacheEnabled()) { + Collection cancerStudyIdCollection = clinicalEventAttributeRequest + .getPatientIdentifiers() + .stream() + .map(PatientIdentifier::getStudyId) + .collect(Collectors.toSet()); + LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); + } + } catch (Exception e) { + LOG.error("exception thrown during extraction of genericAssayDataMultipleStudyFilter: " + e); + return false; + } + return true; + } + } From ac67d8dd8ad6801c57892fc99ca752b7cde7df28 Mon Sep 17 00:00:00 2001 From: Qi-Xuan Lu Date: Fri, 12 Apr 2024 14:51:22 -0400 Subject: [PATCH 04/12] add censored events and complete getSurvivalData logic --- .../service/ClinicalEventService.java | 5 ++- .../impl/ClinicalEventServiceImpl.java | 37 +++++++++++++++---- .../cbioportal/web/SurvivalController.java | 6 ++- .../web/parameter/SurvivalRequest.java | 11 ++++++ 4 files changed, 47 insertions(+), 12 deletions(-) diff --git a/src/main/java/org/cbioportal/service/ClinicalEventService.java b/src/main/java/org/cbioportal/service/ClinicalEventService.java index 68239585b07..92c18b8d336 100644 --- a/src/main/java/org/cbioportal/service/ClinicalEventService.java +++ b/src/main/java/org/cbioportal/service/ClinicalEventService.java @@ -2,7 +2,6 @@ import org.cbioportal.model.ClinicalData; import org.cbioportal.model.ClinicalEvent; -import org.cbioportal.model.ClinicalEventData; import org.cbioportal.model.ClinicalEventTypeCount; import org.cbioportal.model.meta.BaseMeta; import org.cbioportal.service.exception.PatientNotFoundException; @@ -38,7 +37,9 @@ List getSurvivalData(List studyIds, List patientId List startClinicalEventsMeta, Function startPositionIdentifier, List endClinicalEventsMeta, - Function endPositionIdentifier); + Function endPositionIdentifier, + List censoredClinicalEventsMeta, + Function censoredPositionIdentifier); List getClinicalEventsMeta(List studyIds, List patientIds, List clinicalEvents); diff --git a/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java b/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java index 8fca6a37b22..b7cd1eff75f 100644 --- a/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java +++ b/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java @@ -119,8 +119,9 @@ public List getSurvivalData(List studyIds, List startClinicalEventsMeta, Function startPositionIdentifier, List endClinicalEventsMeta, - Function endPositionIdentifier) { - + Function endPositionIdentifier, + List censoredClinicalEventsMeta, + Function censoredPositionIdentifier) { List patientStartEvents = clinicalEventRepository.getTimelineEvents(studyIds, patientIds, startClinicalEventsMeta); List filteredStudyIds = new ArrayList<>(); @@ -129,6 +130,8 @@ public List getSurvivalData(List studyIds, filteredStudyIds.add(clinicalEvent.getStudyId()); filteredPatientIds.add(clinicalEvent.getPatientId()); } + + // only fetch end timeline events for patients that have endClinicalEventsMeta and start timeline events List patientEndEvents = new ArrayList<>(); if (CollectionUtils.isNotEmpty(endClinicalEventsMeta) && CollectionUtils.isNotEmpty(filteredStudyIds)) { patientEndEvents = clinicalEventRepository.getTimelineEvents(filteredStudyIds, filteredPatientIds, endClinicalEventsMeta); @@ -136,31 +139,41 @@ public List getSurvivalData(List studyIds, Map patientEndEventsById = patientEndEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); + // filter out cases where start event is less than end event + patientStartEvents = patientStartEvents.stream() + .filter(x -> + Optional.ofNullable(patientEndEventsById.get(getKey(x))) + .map(endPositionIdentifier) + .map(endDate -> startPositionIdentifier.apply(x) < endDate) + .orElse(true) + ).collect(Collectors.toList()); + filteredStudyIds.clear(); filteredPatientIds.clear(); + // get all the studies that have start events but not end events for (ClinicalEvent clinicalEvent : patientStartEvents.stream().filter(x -> !patientEndEventsById.containsKey(getKey(x))).collect(Collectors.toList())) { filteredStudyIds.add(clinicalEvent.getStudyId()); filteredPatientIds.add(clinicalEvent.getPatientId()); } - List patientLastEvents = new ArrayList<>(); + List patientCensoredEvents = new ArrayList<>(); if (CollectionUtils.isNotEmpty(filteredStudyIds)) { - patientLastEvents = clinicalEventRepository.getTimelineEvents(filteredStudyIds, filteredPatientIds, new ArrayList<>()); + patientCensoredEvents = clinicalEventRepository.getTimelineEvents(filteredStudyIds, filteredPatientIds, censoredClinicalEventsMeta); } - Map patientLastEventsById = patientLastEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); + Map patientCensoredEventsById = patientCensoredEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); return patientStartEvents.stream() .flatMap(x -> { ClinicalData clinicalDataMonths = new ClinicalData(); clinicalDataMonths.setStudyId(x.getStudyId()); clinicalDataMonths.setPatientId(x.getPatientId()); - clinicalDataMonths.setAttrId(attributeIdPrefix+"_MONTHS"); + clinicalDataMonths.setAttrId(attributeIdPrefix + "_MONTHS"); ClinicalData clinicalDataStatus = new ClinicalData(); clinicalDataStatus.setStudyId(x.getStudyId()); clinicalDataStatus.setPatientId(x.getPatientId()); - clinicalDataStatus.setAttrId(attributeIdPrefix+"_STATUS"); + clinicalDataStatus.setAttrId(attributeIdPrefix + "_STATUS"); Integer startDate = startPositionIdentifier.apply(x); Integer endDate; @@ -168,8 +181,16 @@ public List getSurvivalData(List studyIds, clinicalDataStatus.setAttrValue("1:EVENT"); endDate = endPositionIdentifier.apply(patientEndEventsById.get(getKey(x))); } else { + // ignore cases where patient does not have censored timeline events or + // stop date of start event is less than start date of censored events + if (!patientCensoredEventsById.containsKey(getKey(x)) || + startDate >= censoredPositionIdentifier.apply(patientCensoredEventsById.get(getKey(x))) + ) { + return Stream.empty(); + } + clinicalDataStatus.setAttrValue("0:CENSORED"); - endDate = endPositionIdentifier.apply(patientLastEventsById.get(getKey(x))); + endDate = censoredPositionIdentifier.apply(patientCensoredEventsById.get(getKey(x))); } clinicalDataMonths.setAttrValue(String.valueOf((endDate - startDate) / 30.4)); diff --git a/src/main/java/org/cbioportal/web/SurvivalController.java b/src/main/java/org/cbioportal/web/SurvivalController.java index 16452020d97..06588deed39 100644 --- a/src/main/java/org/cbioportal/web/SurvivalController.java +++ b/src/main/java/org/cbioportal/web/SurvivalController.java @@ -64,7 +64,7 @@ public ResponseEntity> fetchSurvivalData( List endClinicalEventsMeta = null; Function endPositionIdentifier = ClinicalEvent::getStopDate; - if(interceptedSurvivalRequest.getEndEventRequestIdentifier() != null) { + if (interceptedSurvivalRequest.getEndEventRequestIdentifier() != null) { endClinicalEventsMeta = getToClinicalEvents(interceptedSurvivalRequest.getEndEventRequestIdentifier()); endPositionIdentifier = getPositionIdentifier(interceptedSurvivalRequest.getEndEventRequestIdentifier().getPosition()); } @@ -75,7 +75,9 @@ public ResponseEntity> fetchSurvivalData( getToClinicalEvents(interceptedSurvivalRequest.getStartEventRequestIdentifier()), getPositionIdentifier(interceptedSurvivalRequest.getStartEventRequestIdentifier().getPosition()), endClinicalEventsMeta, - endPositionIdentifier); + endPositionIdentifier, + getToClinicalEvents(interceptedSurvivalRequest.getCensoredEventRequestIdentifier()), + getPositionIdentifier(interceptedSurvivalRequest.getCensoredEventRequestIdentifier().getPosition())); return new ResponseEntity<>(result, HttpStatus.OK); } diff --git a/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java b/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java index c402e293e81..7f770d9cd42 100644 --- a/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java +++ b/src/main/java/org/cbioportal/web/parameter/SurvivalRequest.java @@ -20,6 +20,9 @@ public class SurvivalRequest implements Serializable { @Valid private ClinicalEventRequestIdentifier endEventRequestIdentifier; + @Valid + private ClinicalEventRequestIdentifier censoredEventRequestIdentifier; + public List getPatientIdentifiers() { return patientIdentifiers; } @@ -51,4 +54,12 @@ public ClinicalEventRequestIdentifier getEndEventRequestIdentifier() { public void setEndEventRequestIdentifier(ClinicalEventRequestIdentifier endEventRequestIdentifier) { this.endEventRequestIdentifier = endEventRequestIdentifier; } + + public ClinicalEventRequestIdentifier getCensoredEventRequestIdentifier() { + return censoredEventRequestIdentifier; + } + + public void setCensoredEventRequestIdentifier(ClinicalEventRequestIdentifier censoredEventRequestIdentifier) { + this.censoredEventRequestIdentifier = censoredEventRequestIdentifier; + } } From 5d0a242712ad18d183e0cc39d16d9abd6ddf2b09 Mon Sep 17 00:00:00 2001 From: Qi-Xuan Lu Date: Mon, 22 Apr 2024 11:21:26 -0400 Subject: [PATCH 05/12] support configurable properties for clinical event types --- .../service/FrontendPropertiesServiceImpl.java | 1 + .../org/cbioportal/web/SurvivalController.java | 15 +++++++++++---- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/src/main/java/org/cbioportal/service/FrontendPropertiesServiceImpl.java b/src/main/java/org/cbioportal/service/FrontendPropertiesServiceImpl.java index da96d0debfa..02f193b08f3 100644 --- a/src/main/java/org/cbioportal/service/FrontendPropertiesServiceImpl.java +++ b/src/main/java/org/cbioportal/service/FrontendPropertiesServiceImpl.java @@ -175,6 +175,7 @@ public enum FrontendProperty { skin_patient_view_copy_number_table_columns_show_on_init("skin.patient_view.copy_number_table.columns.show_on_init", null), skin_patient_view_structural_variant_table_columns_show_on_init("skin.patient_view.structural_variant_table.columns.show_on_init", null), skin_results_view_tables_default_sort_column("skin.results_view.tables.default_sort_column", null), + skin_survival_plot_clinical_event_types_show_on_init("skin.survival_plot.clinical_event_types.show_on_init", null), skin_patient_view_tables_default_sort_column("skin.patient_view.tables.default_sort_column", null), enable_treatment_groups("enable_treatment_groups", null), diff --git a/src/main/java/org/cbioportal/web/SurvivalController.java b/src/main/java/org/cbioportal/web/SurvivalController.java index 06588deed39..e923a33a463 100644 --- a/src/main/java/org/cbioportal/web/SurvivalController.java +++ b/src/main/java/org/cbioportal/web/SurvivalController.java @@ -62,12 +62,19 @@ public ResponseEntity> fetchSurvivalData( patientIds.add(patientIdentifier.getPatientId()); } - List endClinicalEventsMeta = null; + List endClinicalEventsMeta = new ArrayList<>(); Function endPositionIdentifier = ClinicalEvent::getStopDate; if (interceptedSurvivalRequest.getEndEventRequestIdentifier() != null) { - endClinicalEventsMeta = getToClinicalEvents(interceptedSurvivalRequest.getEndEventRequestIdentifier()); + endClinicalEventsMeta = getToClinicalEvents(interceptedSurvivalRequest.getEndEventRequestIdentifier()); endPositionIdentifier = getPositionIdentifier(interceptedSurvivalRequest.getEndEventRequestIdentifier().getPosition()); } + + List censoredClinicalEventsMeta = new ArrayList<>(); + Function censoredPositionIdentifier = ClinicalEvent::getStopDate; + if (interceptedSurvivalRequest.getCensoredEventRequestIdentifier() != null) { + censoredClinicalEventsMeta = getToClinicalEvents(interceptedSurvivalRequest.getCensoredEventRequestIdentifier()); + censoredPositionIdentifier = getPositionIdentifier(interceptedSurvivalRequest.getCensoredEventRequestIdentifier().getPosition()); + } List result = clinicalEventService.getSurvivalData(studyIds, patientIds, @@ -76,8 +83,8 @@ public ResponseEntity> fetchSurvivalData( getPositionIdentifier(interceptedSurvivalRequest.getStartEventRequestIdentifier().getPosition()), endClinicalEventsMeta, endPositionIdentifier, - getToClinicalEvents(interceptedSurvivalRequest.getCensoredEventRequestIdentifier()), - getPositionIdentifier(interceptedSurvivalRequest.getCensoredEventRequestIdentifier().getPosition())); + censoredClinicalEventsMeta, + censoredPositionIdentifier); return new ResponseEntity<>(result, HttpStatus.OK); } From 7c8b8088e16e24e4178db48d2e3b7fe6ccb4284d Mon Sep 17 00:00:00 2001 From: Qi-Xuan Lu Date: Wed, 1 May 2024 16:45:06 -0400 Subject: [PATCH 06/12] fix clinical event mybatis tests --- .../TreatmentMyBatisRepositoryTest.java | 81 +++++++++++-------- src/test/resources/testSql.sql | 2 +- 2 files changed, 50 insertions(+), 33 deletions(-) diff --git a/src/test/java/org/cbioportal/persistence/mybatis/TreatmentMyBatisRepositoryTest.java b/src/test/java/org/cbioportal/persistence/mybatis/TreatmentMyBatisRepositoryTest.java index 99f518f9a27..5cdc3506c34 100644 --- a/src/test/java/org/cbioportal/persistence/mybatis/TreatmentMyBatisRepositoryTest.java +++ b/src/test/java/org/cbioportal/persistence/mybatis/TreatmentMyBatisRepositoryTest.java @@ -1,13 +1,8 @@ package org.cbioportal.persistence.mybatis; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import org.cbioportal.model.ClinicalEventKeyCode; import org.cbioportal.model.ClinicalEventSample; import org.cbioportal.model.Treatment; -import org.cbioportal.model.ClinicalEventKeyCode; import org.cbioportal.persistence.TreatmentRepository; import org.cbioportal.persistence.mybatis.config.TestConfig; import org.junit.Assert; @@ -17,6 +12,12 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + @RunWith(SpringJUnit4ClassRunner.class) @SpringBootTest(classes = {TreatmentMyBatisRepository.class, TestConfig.class}) public class TreatmentMyBatisRepositoryTest { @@ -26,16 +27,22 @@ public class TreatmentMyBatisRepositoryTest { @Test public void getTreatmentsByPatientId() { - Treatment treatment = new Treatment(); - treatment.setTreatment("Madeupanib"); - treatment.setStudyId("study_tcga_pub"); - treatment.setPatientId("TCGA-A1-A0SD"); - treatment.setStart(213); - treatment.setStop(445); + Treatment treatment1 = new Treatment(); + treatment1.setTreatment("Madeupanib"); + treatment1.setStudyId("study_tcga_pub"); + treatment1.setPatientId("TCGA-A1-A0SD"); + treatment1.setStart(213); + treatment1.setStop(445); + + Treatment treatment2 = new Treatment(); + treatment2.setTreatment("abc"); + treatment2.setStudyId("study_tcga_pub"); + treatment2.setPatientId("TCGA-A1-A0SD"); + treatment2.setStart(313); + treatment2.setStop(543); Map> expected = new HashMap<>(); - expected.put("TCGA-A1-A0SD", Collections.singletonList(treatment)); - + expected.put("TCGA-A1-A0SD", Arrays.asList(treatment1, treatment2)); Map> actual = treatmentRepository.getTreatmentsByPatientId( Collections.singletonList("TCGA-A1-A0SD-01"), @@ -43,30 +50,41 @@ public void getTreatmentsByPatientId() { ClinicalEventKeyCode.Agent ); - Assert.assertEquals(actual, expected); } - @Test public void getTreatmentAgentsByPatientId() { - Treatment targetA = new Treatment(); - targetA.setTreatment("Directly to forehead"); - targetA.setStudyId("study_tcga_pub"); - targetA.setPatientId("TCGA-A1-A0SD"); - targetA.setStart(213); - targetA.setStop(445); - - Treatment targetB = new Treatment(); - targetB.setTreatment("Elbow"); - targetB.setStudyId("study_tcga_pub"); - targetB.setPatientId("TCGA-A1-A0SD"); - targetB.setStart(213); - targetB.setStop(445); + Treatment treatment1 = new Treatment(); + treatment1.setTreatment("Directly to forehead"); + treatment1.setStudyId("study_tcga_pub"); + treatment1.setPatientId("TCGA-A1-A0SD"); + treatment1.setStart(213); + treatment1.setStop(445); + + Treatment treatment2 = new Treatment(); + treatment2.setTreatment("Elbow"); + treatment2.setStudyId("study_tcga_pub"); + treatment2.setPatientId("TCGA-A1-A0SD"); + treatment2.setStart(213); + treatment2.setStop(445); + + Treatment treatment3 = new Treatment(); + treatment3.setTreatment("Left arm"); + treatment3.setStudyId("study_tcga_pub"); + treatment3.setPatientId("TCGA-A1-A0SD"); + treatment3.setStart(313); + treatment3.setStop(543); + + Treatment treatment4 = new Treatment(); + treatment4.setTreatment("Ankle"); + treatment4.setStudyId("study_tcga_pub"); + treatment4.setPatientId("TCGA-A1-A0SD"); + treatment4.setStart(313); + treatment4.setStop(543); Map> expected = new HashMap<>(); - expected.put("TCGA-A1-A0SD", Arrays.asList(targetA, targetB)); - + expected.put("TCGA-A1-A0SD", Arrays.asList(treatment1, treatment2, treatment3, treatment4)); Map> actual = treatmentRepository.getTreatmentsByPatientId( Collections.singletonList("TCGA-A1-A0SD-01"), @@ -74,7 +92,6 @@ public void getTreatmentAgentsByPatientId() { ClinicalEventKeyCode.AgentTarget ); - Assert.assertEquals(actual, expected); } diff --git a/src/test/resources/testSql.sql b/src/test/resources/testSql.sql index 6f21428600f..01985279c97 100644 --- a/src/test/resources/testSql.sql +++ b/src/test/resources/testSql.sql @@ -471,7 +471,7 @@ INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (3,'SAMPLE_ INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (4,'SAMPLE_ID','TCGA-A1-A0SD-01'); INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (5,'EVENT_TYPE_DETAILED','AA III Recurrence1'); INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (5,'AGENT','abc'); -INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (5,'AGENT_TARGET','Directly to forehead, Elbow'); +INSERT INTO clinical_event_data (CLINICAL_EVENT_ID,KEY,VALUE) VALUES (5,'AGENT_TARGET','Left arm, Ankle'); INSERT INTO geneset (ID,GENETIC_ENTITY_ID,EXTERNAL_ID,NAME,DESCRIPTION,REF_LINK) VALUES (1,17,'MORF_ATRX','MORF ATRX name','Morf description','https://morf_link'); INSERT INTO geneset (ID,GENETIC_ENTITY_ID,EXTERNAL_ID,NAME,DESCRIPTION,REF_LINK) VALUES (2,18,'HINATA_NFKB_MATRIX','HINATA NFKB MATRIX name','Hinata description','https://hinata_link'); From 2930f21ef29e2b941bb308b3bb8449a0ba1d9ef9 Mon Sep 17 00:00:00 2001 From: Qi-Xuan Lu Date: Thu, 2 May 2024 12:36:50 -0400 Subject: [PATCH 07/12] Remove min constraint on clinicalEventRequests --- .../web/parameter/ClinicalEventRequestIdentifier.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java b/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java index 8a36e4f910a..0bebd3e8c49 100644 --- a/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java +++ b/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java @@ -8,7 +8,7 @@ public class ClinicalEventRequestIdentifier implements Serializable { - @Size(min = 1, max = PagingConstants.MAX_PAGE_SIZE) + @Size(max = PagingConstants.MAX_PAGE_SIZE) Set clinicalEventRequests; @NotNull OccurrencePosition position; From 122988b16ab236fbbd7086fa0944a5de719ef0cd Mon Sep 17 00:00:00 2001 From: Qi-Xuan Lu Date: Wed, 8 May 2024 14:40:41 -0400 Subject: [PATCH 08/12] Fix Sonarcloud's issues --- .../org/cbioportal/model/SurvivalEvent.java | 62 ++++++ .../service/ClinicalEventService.java | 9 +- .../impl/ClinicalEventServiceImpl.java | 69 ++++--- .../web/ClinicalEventController.java | 5 +- .../cbioportal/web/SurvivalController.java | 42 ++-- .../ClinicalEventAttributeRequest.java | 2 +- .../ClinicalEventRequestIdentifier.java | 4 +- ...volvedCancerStudyExtractorInterceptor.java | 191 +++++++++--------- .../ClinicalEventMyBatisRepositoryTest.java | 60 ++---- 9 files changed, 253 insertions(+), 191 deletions(-) create mode 100644 src/main/java/org/cbioportal/model/SurvivalEvent.java diff --git a/src/main/java/org/cbioportal/model/SurvivalEvent.java b/src/main/java/org/cbioportal/model/SurvivalEvent.java new file mode 100644 index 00000000000..baa2ce94b32 --- /dev/null +++ b/src/main/java/org/cbioportal/model/SurvivalEvent.java @@ -0,0 +1,62 @@ +package org.cbioportal.model; + +import java.util.List; +import java.util.function.ToIntFunction; + +public class SurvivalEvent { + List startClinicalEventsMeta; + ToIntFunction startPositionIdentifier; + List endClinicalEventsMeta; + + public List getStartClinicalEventsMeta() { + return startClinicalEventsMeta; + } + + public void setStartClinicalEventsMeta(List startClinicalEventsMeta) { + this.startClinicalEventsMeta = startClinicalEventsMeta; + } + + public ToIntFunction getStartPositionIdentifier() { + return startPositionIdentifier; + } + + public void setStartPositionIdentifier(ToIntFunction startPositionIdentifier) { + this.startPositionIdentifier = startPositionIdentifier; + } + + public List getEndClinicalEventsMeta() { + return endClinicalEventsMeta; + } + + public void setEndClinicalEventsMeta(List endClinicalEventsMeta) { + this.endClinicalEventsMeta = endClinicalEventsMeta; + } + + public ToIntFunction getEndPositionIdentifier() { + return endPositionIdentifier; + } + + public void setEndPositionIdentifier(ToIntFunction endPositionIdentifier) { + this.endPositionIdentifier = endPositionIdentifier; + } + + public List getCensoredClinicalEventsMeta() { + return censoredClinicalEventsMeta; + } + + public void setCensoredClinicalEventsMeta(List censoredClinicalEventsMeta) { + this.censoredClinicalEventsMeta = censoredClinicalEventsMeta; + } + + public ToIntFunction getCensoredPositionIdentifier() { + return censoredPositionIdentifier; + } + + public void setCensoredPositionIdentifier(ToIntFunction censoredPositionIdentifier) { + this.censoredPositionIdentifier = censoredPositionIdentifier; + } + + ToIntFunction endPositionIdentifier; + List censoredClinicalEventsMeta; + ToIntFunction censoredPositionIdentifier; +} diff --git a/src/main/java/org/cbioportal/service/ClinicalEventService.java b/src/main/java/org/cbioportal/service/ClinicalEventService.java index 92c18b8d336..e542d512517 100644 --- a/src/main/java/org/cbioportal/service/ClinicalEventService.java +++ b/src/main/java/org/cbioportal/service/ClinicalEventService.java @@ -3,6 +3,7 @@ import org.cbioportal.model.ClinicalData; import org.cbioportal.model.ClinicalEvent; import org.cbioportal.model.ClinicalEventTypeCount; +import org.cbioportal.model.SurvivalEvent; import org.cbioportal.model.meta.BaseMeta; import org.cbioportal.service.exception.PatientNotFoundException; import org.cbioportal.service.exception.StudyNotFoundException; @@ -10,7 +11,6 @@ import java.util.List; import java.util.Map; import java.util.Set; -import java.util.function.Function; public interface ClinicalEventService { @@ -34,12 +34,7 @@ BaseMeta getMetaClinicalEvents(String studyId) List getSurvivalData(List studyIds, List patientIds, String attributeIdPrefix, - List startClinicalEventsMeta, - Function startPositionIdentifier, - List endClinicalEventsMeta, - Function endPositionIdentifier, - List censoredClinicalEventsMeta, - Function censoredPositionIdentifier); + SurvivalEvent survivalEvent); List getClinicalEventsMeta(List studyIds, List patientIds, List clinicalEvents); diff --git a/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java b/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java index b7cd1eff75f..2ffd2520352 100644 --- a/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java +++ b/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java @@ -1,7 +1,12 @@ package org.cbioportal.service.impl; import org.apache.commons.collections4.CollectionUtils; -import org.cbioportal.model.*; +import org.cbioportal.model.ClinicalData; +import org.cbioportal.model.ClinicalEvent; +import org.cbioportal.model.ClinicalEventData; +import org.cbioportal.model.ClinicalEventTypeCount; +import org.cbioportal.model.Patient; +import org.cbioportal.model.SurvivalEvent; import org.cbioportal.model.meta.BaseMeta; import org.cbioportal.persistence.ClinicalEventRepository; import org.cbioportal.service.ClinicalEventService; @@ -11,8 +16,14 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; -import java.util.*; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; import java.util.function.Function; +import java.util.function.ToIntFunction; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -116,12 +127,14 @@ public List getClinicalEventTypeCounts(List stud public List getSurvivalData(List studyIds, List patientIds, String attributeIdPrefix, - List startClinicalEventsMeta, - Function startPositionIdentifier, - List endClinicalEventsMeta, - Function endPositionIdentifier, - List censoredClinicalEventsMeta, - Function censoredPositionIdentifier) { + SurvivalEvent survivalEvent) { + List startClinicalEventsMeta = survivalEvent.getStartClinicalEventsMeta(); + ToIntFunction startPositionIdentifier = survivalEvent.getStartPositionIdentifier(); + List endClinicalEventsMeta = survivalEvent.getEndClinicalEventsMeta(); + ToIntFunction endPositionIdentifier = survivalEvent.getEndPositionIdentifier(); + List censoredClinicalEventsMeta = survivalEvent.getCensoredClinicalEventsMeta(); + ToIntFunction censoredPositionIdentifier = survivalEvent.getCensoredPositionIdentifier(); + List patientStartEvents = clinicalEventRepository.getTimelineEvents(studyIds, patientIds, startClinicalEventsMeta); List filteredStudyIds = new ArrayList<>(); @@ -141,17 +154,17 @@ public List getSurvivalData(List studyIds, // filter out cases where start event is less than end event patientStartEvents = patientStartEvents.stream() - .filter(x -> - Optional.ofNullable(patientEndEventsById.get(getKey(x))) - .map(endPositionIdentifier) - .map(endDate -> startPositionIdentifier.apply(x) < endDate) + .filter(event -> + Optional.ofNullable(patientEndEventsById.get(getKey(event))) + .map(endPositionIdentifier::applyAsInt) + .map(endDate -> startPositionIdentifier.applyAsInt(event) < endDate) .orElse(true) - ).collect(Collectors.toList()); - + ).toList(); + filteredStudyIds.clear(); filteredPatientIds.clear(); // get all the studies that have start events but not end events - for (ClinicalEvent clinicalEvent : patientStartEvents.stream().filter(x -> !patientEndEventsById.containsKey(getKey(x))).collect(Collectors.toList())) { + for (ClinicalEvent clinicalEvent : patientStartEvents.stream().filter(event -> !patientEndEventsById.containsKey(getKey(event))).toList()) { filteredStudyIds.add(clinicalEvent.getStudyId()); filteredPatientIds.add(clinicalEvent.getPatientId()); } @@ -164,38 +177,38 @@ public List getSurvivalData(List studyIds, Map patientCensoredEventsById = patientCensoredEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); return patientStartEvents.stream() - .flatMap(x -> { + .flatMap(event -> { ClinicalData clinicalDataMonths = new ClinicalData(); - clinicalDataMonths.setStudyId(x.getStudyId()); - clinicalDataMonths.setPatientId(x.getPatientId()); + clinicalDataMonths.setStudyId(event.getStudyId()); + clinicalDataMonths.setPatientId(event.getPatientId()); clinicalDataMonths.setAttrId(attributeIdPrefix + "_MONTHS"); ClinicalData clinicalDataStatus = new ClinicalData(); - clinicalDataStatus.setStudyId(x.getStudyId()); - clinicalDataStatus.setPatientId(x.getPatientId()); + clinicalDataStatus.setStudyId(event.getStudyId()); + clinicalDataStatus.setPatientId(event.getPatientId()); clinicalDataStatus.setAttrId(attributeIdPrefix + "_STATUS"); - Integer startDate = startPositionIdentifier.apply(x); - Integer endDate; - if (patientEndEventsById.containsKey(getKey(x))) { + int startDate = startPositionIdentifier.applyAsInt(event); + int endDate; + if (patientEndEventsById.containsKey(getKey(event))) { clinicalDataStatus.setAttrValue("1:EVENT"); - endDate = endPositionIdentifier.apply(patientEndEventsById.get(getKey(x))); + endDate = endPositionIdentifier.applyAsInt(patientEndEventsById.get(getKey(event))); } else { // ignore cases where patient does not have censored timeline events or // stop date of start event is less than start date of censored events - if (!patientCensoredEventsById.containsKey(getKey(x)) || - startDate >= censoredPositionIdentifier.apply(patientCensoredEventsById.get(getKey(x))) + if (!patientCensoredEventsById.containsKey(getKey(event)) || + startDate >= censoredPositionIdentifier.applyAsInt(patientCensoredEventsById.get(getKey(event))) ) { return Stream.empty(); } clinicalDataStatus.setAttrValue("0:CENSORED"); - endDate = censoredPositionIdentifier.apply(patientCensoredEventsById.get(getKey(x))); + endDate = censoredPositionIdentifier.applyAsInt(patientCensoredEventsById.get(getKey(event))); } clinicalDataMonths.setAttrValue(String.valueOf((endDate - startDate) / 30.4)); return Stream.of(clinicalDataMonths, clinicalDataStatus); - }).collect(Collectors.toList()); + }).toList(); } @Override diff --git a/src/main/java/org/cbioportal/web/ClinicalEventController.java b/src/main/java/org/cbioportal/web/ClinicalEventController.java index 478c9f2932c..cb8efec5e75 100644 --- a/src/main/java/org/cbioportal/web/ClinicalEventController.java +++ b/src/main/java/org/cbioportal/web/ClinicalEventController.java @@ -41,7 +41,6 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; -import java.util.stream.Collectors; @InternalApi @RestController() @@ -135,6 +134,8 @@ public ResponseEntity> getAllClinicalEventsInStudy( consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE) @Operation(description = "Fetch clinical events meta") + @ApiResponse(responseCode = "200", description = "OK", + content = @Content(array = @ArraySchema(schema = @Schema(implementation = ClinicalEvent.class)))) public ResponseEntity> fetchClinicalEventsMeta( @Parameter(required = true, description = "clinical events Request") @Valid @RequestBody(required = false) ClinicalEventAttributeRequest clinicalEventAttributeRequest, @@ -158,7 +159,7 @@ public ResponseEntity> fetchClinicalEventsMeta( clinicalEvent.setAttributes(x.getAttributes()); return clinicalEvent; }) - .collect(Collectors.toList()); + .toList(); return new ResponseEntity<>(clinicalEventService.getClinicalEventsMeta( studyIds, patientIds, clinicalEventsRequest), HttpStatus.OK); diff --git a/src/main/java/org/cbioportal/web/SurvivalController.java b/src/main/java/org/cbioportal/web/SurvivalController.java index e923a33a463..8032c6db697 100644 --- a/src/main/java/org/cbioportal/web/SurvivalController.java +++ b/src/main/java/org/cbioportal/web/SurvivalController.java @@ -2,10 +2,15 @@ import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.ArraySchema; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.Schema; +import io.swagger.v3.oas.annotations.responses.ApiResponse; import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.validation.Valid; import org.cbioportal.model.ClinicalData; import org.cbioportal.model.ClinicalEvent; +import org.cbioportal.model.SurvivalEvent; import org.cbioportal.service.ClinicalEventService; import org.cbioportal.web.config.annotation.InternalApi; import org.cbioportal.web.parameter.ClinicalEventRequestIdentifier; @@ -27,8 +32,7 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; -import java.util.function.Function; -import java.util.stream.Collectors; +import java.util.function.ToIntFunction; @InternalApi @RestController() @@ -36,9 +40,12 @@ @Validated @Tag(name = "Survival", description = " ") public class SurvivalController { - + private final ClinicalEventService clinicalEventService; + @Autowired - private ClinicalEventService clinicalEventService; + public SurvivalController(ClinicalEventService clinicalEventService) { + this.clinicalEventService = clinicalEventService; + } @PreAuthorize("hasPermission(#involvedCancerStudies, 'Collection', T(org.cbioportal.utils.security.AccessLevel).READ)") @RequestMapping(value = "/survival-data/fetch", @@ -46,6 +53,8 @@ public class SurvivalController { consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE) @Operation(description = "Fetch survival data") + @ApiResponse(responseCode = "200", description = "OK", + content = @Content(array = @ArraySchema(schema = @Schema(implementation = ClinicalData.class)))) public ResponseEntity> fetchSurvivalData( @Parameter(required = true, description = "Survival Data Request") @Valid @RequestBody(required = false) SurvivalRequest survivalRequest, @@ -63,28 +72,31 @@ public ResponseEntity> fetchSurvivalData( } List endClinicalEventsMeta = new ArrayList<>(); - Function endPositionIdentifier = ClinicalEvent::getStopDate; + ToIntFunction endPositionIdentifier = ClinicalEvent::getStopDate; if (interceptedSurvivalRequest.getEndEventRequestIdentifier() != null) { endClinicalEventsMeta = getToClinicalEvents(interceptedSurvivalRequest.getEndEventRequestIdentifier()); endPositionIdentifier = getPositionIdentifier(interceptedSurvivalRequest.getEndEventRequestIdentifier().getPosition()); } - + List censoredClinicalEventsMeta = new ArrayList<>(); - Function censoredPositionIdentifier = ClinicalEvent::getStopDate; + ToIntFunction censoredPositionIdentifier = ClinicalEvent::getStopDate; if (interceptedSurvivalRequest.getCensoredEventRequestIdentifier() != null) { censoredClinicalEventsMeta = getToClinicalEvents(interceptedSurvivalRequest.getCensoredEventRequestIdentifier()); censoredPositionIdentifier = getPositionIdentifier(interceptedSurvivalRequest.getCensoredEventRequestIdentifier().getPosition()); } + SurvivalEvent survivalEvent = new SurvivalEvent(); + survivalEvent.setStartClinicalEventsMeta(getToClinicalEvents(interceptedSurvivalRequest.getStartEventRequestIdentifier())); + survivalEvent.setStartPositionIdentifier(getPositionIdentifier(interceptedSurvivalRequest.getStartEventRequestIdentifier().getPosition())); + survivalEvent.setEndClinicalEventsMeta(endClinicalEventsMeta); + survivalEvent.setEndPositionIdentifier(endPositionIdentifier); + survivalEvent.setCensoredClinicalEventsMeta(censoredClinicalEventsMeta); + survivalEvent.setCensoredPositionIdentifier(censoredPositionIdentifier); + List result = clinicalEventService.getSurvivalData(studyIds, patientIds, interceptedSurvivalRequest.getAttributeIdPrefix(), - getToClinicalEvents(interceptedSurvivalRequest.getStartEventRequestIdentifier()), - getPositionIdentifier(interceptedSurvivalRequest.getStartEventRequestIdentifier().getPosition()), - endClinicalEventsMeta, - endPositionIdentifier, - censoredClinicalEventsMeta, - censoredPositionIdentifier); + survivalEvent); return new ResponseEntity<>(result, HttpStatus.OK); } @@ -96,10 +108,10 @@ private static List getToClinicalEvents(ClinicalEventRequestIdent clinicalEvent.setAttributes(x.getAttributes()); return clinicalEvent; - }).collect(Collectors.toList()); + }).toList(); } - private static Function getPositionIdentifier(OccurrencePosition position) { + private ToIntFunction getPositionIdentifier(OccurrencePosition position) { return position.equals(OccurrencePosition.FIRST) ? ClinicalEvent::getStartDate : ClinicalEvent::getStopDate; } } diff --git a/src/main/java/org/cbioportal/web/parameter/ClinicalEventAttributeRequest.java b/src/main/java/org/cbioportal/web/parameter/ClinicalEventAttributeRequest.java index 66f8f59d3ef..4cc2d6f254e 100644 --- a/src/main/java/org/cbioportal/web/parameter/ClinicalEventAttributeRequest.java +++ b/src/main/java/org/cbioportal/web/parameter/ClinicalEventAttributeRequest.java @@ -11,7 +11,7 @@ public class ClinicalEventAttributeRequest implements Serializable { @Size(min = 1, max = PagingConstants.MAX_PAGE_SIZE) private List patientIdentifiers; - Set clinicalEventRequests; + private Set clinicalEventRequests; public List getPatientIdentifiers() { return patientIdentifiers; diff --git a/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java b/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java index 0bebd3e8c49..2d38a85e91c 100644 --- a/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java +++ b/src/main/java/org/cbioportal/web/parameter/ClinicalEventRequestIdentifier.java @@ -9,9 +9,9 @@ public class ClinicalEventRequestIdentifier implements Serializable { @Size(max = PagingConstants.MAX_PAGE_SIZE) - Set clinicalEventRequests; + private Set clinicalEventRequests; @NotNull - OccurrencePosition position; + private OccurrencePosition position; public Set getClinicalEventRequests() { return clinicalEventRequests; diff --git a/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java b/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java index a39028a6430..a5eeef23a2e 100644 --- a/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java +++ b/src/main/java/org/cbioportal/web/util/InvolvedCancerStudyExtractorInterceptor.java @@ -74,6 +74,7 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Set; @@ -207,16 +208,16 @@ public class InvolvedCancerStudyExtractorInterceptor implements HandlerIntercept private boolean extractAttributesFromPatientFilter(HttpServletRequest request) { try { PatientFilter patientFilter = objectMapper.readValue(request.getInputStream(), PatientFilter.class); - LOG.debug("extracted patientFilter: " + patientFilter.toString()); - LOG.debug("setting interceptedPatientFilter to " + patientFilter); + LOG.debug("extracted patientFilter: {}", patientFilter); + LOG.debug("setting interceptedPatientFilter to {}", patientFilter); request.setAttribute("interceptedPatientFilter", patientFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromPatientFilter(patientFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of patientFilter: " + e); + LOG.error("exception thrown during extraction of patientFilter: {}", e.getMessage()); return false; } return true; @@ -238,16 +239,16 @@ private Collection extractCancerStudyIdsFromPatientFilter(PatientFilter private boolean extractAttributesFromSampleFilter(HttpServletRequest request) { try { SampleFilter sampleFilter = objectMapper.readValue(request.getInputStream(), SampleFilter.class); - LOG.debug("extracted sampleFilter: " + sampleFilter.toString()); - LOG.debug("setting interceptedSampleFilter to " + sampleFilter); + LOG.debug("extracted sampleFilter: {}", sampleFilter); + LOG.debug("setting interceptedSampleFilter to {}", sampleFilter); request.setAttribute("interceptedSampleFilter", sampleFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromSampleFilter(sampleFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of sampleFilter: " + e); + LOG.error("exception thrown during extraction of sampleFilter: {}", e.getMessage()); return false; } return true; @@ -269,16 +270,16 @@ private Collection extractCancerStudyIdsFromSampleFilter(SampleFilter sa private boolean extractAttributesFromMolecularProfileFilter(HttpServletRequest request) { try { MolecularProfileFilter molecularProfileFilter = objectMapper.readValue(request.getInputStream(), MolecularProfileFilter.class); - LOG.debug("extracted molecularProfileFilter: " + molecularProfileFilter.toString()); - LOG.debug("setting interceptedMolecularProfileFilter to " + molecularProfileFilter); + LOG.debug("extracted molecularProfileFilter: {}", molecularProfileFilter); + LOG.debug("setting interceptedMolecularProfileFilter to {}", molecularProfileFilter); request.setAttribute("interceptedMolecularProfileFilter", molecularProfileFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromMolecularProfileFilter(molecularProfileFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of molecularProfileFilter: " + e); + LOG.error("exception thrown during extraction of molecularProfileFilter: {}", e.getMessage()); return false; } return true; @@ -298,16 +299,16 @@ private Collection extractCancerStudyIdsFromMolecularProfileFilter(Molec private boolean extractAttributesFromClinicalAttributeCountFilter(HttpServletRequest request) { try { ClinicalAttributeCountFilter clinicalAttributeCountFilter = objectMapper.readValue(request.getInputStream(), ClinicalAttributeCountFilter.class); - LOG.debug("extracted clinicalAttributeCountFilter: " + clinicalAttributeCountFilter.toString()); - LOG.debug("setting interceptedClinicalAttributeCountFilter to " + clinicalAttributeCountFilter); + LOG.debug("extracted clinicalAttributeCountFilter: {}", clinicalAttributeCountFilter); + LOG.debug("setting interceptedClinicalAttributeCountFilter to {}", clinicalAttributeCountFilter); request.setAttribute("interceptedClinicalAttributeCountFilter", clinicalAttributeCountFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromClinicalAttributeCountFilter(clinicalAttributeCountFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of clinicalAttributeCountFilter: " + e); + LOG.error("exception thrown during extraction of clinicalAttributeCountFilter: {}", e.getMessage()); return false; } return true; @@ -317,7 +318,7 @@ private Collection extractCancerStudyIdsFromClinicalAttributeCountFilter // use hashset as the study list in the clinicalAttributeCountFilter may be populated with many duplicate values Set studyIdSet = new HashSet<>(); if (clinicalAttributeCountFilter.getSampleListId() != null) { - extractCancerStudyIdsFromSampleListIds(Arrays.asList(clinicalAttributeCountFilter.getSampleListId()), studyIdSet); + extractCancerStudyIdsFromSampleListIds(Collections.singletonList(clinicalAttributeCountFilter.getSampleListId()), studyIdSet); } else { extractCancerStudyIdsFromSampleIdentifiers(clinicalAttributeCountFilter.getSampleIdentifiers(), studyIdSet); } @@ -327,16 +328,16 @@ private Collection extractCancerStudyIdsFromClinicalAttributeCountFilter private boolean extractAttributesFromClinicalDataMultiStudyFilter(HttpServletRequest request) { try { ClinicalDataMultiStudyFilter clinicalDataMultiStudyFilter = objectMapper.readValue(request.getInputStream(), ClinicalDataMultiStudyFilter.class); - LOG.debug("extracted clinicalDataMultiStudyFilter: " + clinicalDataMultiStudyFilter.toString()); - LOG.debug("setting interceptedClinicalDataMultiStudyFilter to " + clinicalDataMultiStudyFilter); + LOG.debug("extracted clinicalDataMultiStudyFilter: {}", clinicalDataMultiStudyFilter); + LOG.debug("setting interceptedClinicalDataMultiStudyFilter to {}", clinicalDataMultiStudyFilter); request.setAttribute("interceptedClinicalDataMultiStudyFilter", clinicalDataMultiStudyFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromClinicalDataMultiStudyFilter(clinicalDataMultiStudyFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of clinicalDataMultiStudyFilter: " + e); + LOG.error("exception thrown during extraction of clinicalDataMultiStudyFilter: {}", e.getMessage()); return false; } return true; @@ -354,16 +355,16 @@ private Collection extractCancerStudyIdsFromClinicalDataMultiStudyFilter private boolean extractAttributesFromGenePanelDataMultipleStudyFilter(HttpServletRequest request) { try { GenePanelDataMultipleStudyFilter genePanelDataMultipleStudyFilter = objectMapper.readValue(request.getInputStream(), GenePanelDataMultipleStudyFilter.class); - LOG.debug("extracted genePanelDataMultipleStudyFilter: " + genePanelDataMultipleStudyFilter.toString()); - LOG.debug("setting interceptedGenePanelDataMultipleStudyFilter to " + genePanelDataMultipleStudyFilter); + LOG.debug("extracted genePanelDataMultipleStudyFilter: {}", genePanelDataMultipleStudyFilter); + LOG.debug("setting interceptedGenePanelDataMultipleStudyFilter to {}", genePanelDataMultipleStudyFilter); request.setAttribute("interceptedGenePanelDataMultipleStudyFilter", genePanelDataMultipleStudyFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromGenePanelDataMultipleStudyFilter(genePanelDataMultipleStudyFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of genePanelSampleMolecularIdentifiers: " + e); + LOG.error("exception thrown during extraction of genePanelSampleMolecularIdentifiers: {}", e.getMessage()); return false; } return true; @@ -382,16 +383,16 @@ private Collection extractCancerStudyIdsFromGenePanelDataMultipleStudyFi private boolean extractAttributesFromMolecularDataMultipleStudyFilter(HttpServletRequest request) { try { MolecularDataMultipleStudyFilter molecularDataMultipleStudyFilter = objectMapper.readValue(request.getInputStream(), MolecularDataMultipleStudyFilter.class); - LOG.debug("extracted molecularDataMultipleStudyFilter: " + molecularDataMultipleStudyFilter.toString()); - LOG.debug("setting interceptedMolecularDataMultipleStudyFilter to " + molecularDataMultipleStudyFilter); + LOG.debug("extracted molecularDataMultipleStudyFilter: {}", molecularDataMultipleStudyFilter); + LOG.debug("setting interceptedMolecularDataMultipleStudyFilter to {}", molecularDataMultipleStudyFilter); request.setAttribute("interceptedMolecularDataMultipleStudyFilter", molecularDataMultipleStudyFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromMolecularDataMultipleStudyFilter(molecularDataMultipleStudyFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of molecularDataMultipleStudyFilter: " + e); + LOG.error("exception thrown during extraction of molecularDataMultipleStudyFilter: {}", e.getMessage()); return false; } return true; @@ -410,16 +411,16 @@ private Collection extractCancerStudyIdsFromMolecularDataMultipleStudyFi private boolean extractAttributesFromGenericAssayDataMultipleStudyFilter(HttpServletRequest request) { try { GenericAssayDataMultipleStudyFilter genericAssayDataMultipleStudyFilter = objectMapper.readValue(request.getInputStream(), GenericAssayDataMultipleStudyFilter.class); - LOG.debug("extracted genericAssayDataMultipleStudyFilter: " + genericAssayDataMultipleStudyFilter.toString()); - LOG.debug("setting interceptedGenericAssayDataMultipleStudyFilter to " + genericAssayDataMultipleStudyFilter); + LOG.debug("extracted genericAssayDataMultipleStudyFilter: {}", genericAssayDataMultipleStudyFilter); + LOG.debug("setting interceptedGenericAssayDataMultipleStudyFilter to {}", genericAssayDataMultipleStudyFilter); request.setAttribute("interceptedGenericAssayDataMultipleStudyFilter", genericAssayDataMultipleStudyFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromGenericAssayDataMultipleStudyFilter(genericAssayDataMultipleStudyFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of genericAssayDataMultipleStudyFilter: " + e); + LOG.error("exception thrown during extraction of genericAssayDataMultipleStudyFilter: {}", e.getMessage()); return false; } return true; @@ -438,16 +439,16 @@ private Collection extractCancerStudyIdsFromGenericAssayDataMultipleStud private boolean extractAttributesFromMutationMultipleStudyFilter(HttpServletRequest request) { try { MutationMultipleStudyFilter mutationMultipleStudyFilter = objectMapper.readValue(request.getInputStream(), MutationMultipleStudyFilter.class); - LOG.debug("extracted mutationMultipleStudyFilter: " + mutationMultipleStudyFilter.toString()); - LOG.debug("setting interceptedMutationMultipleStudyFilter to " + mutationMultipleStudyFilter); + LOG.debug("extracted mutationMultipleStudyFilter: {}", mutationMultipleStudyFilter); + LOG.debug("setting interceptedMutationMultipleStudyFilter to {}", mutationMultipleStudyFilter); request.setAttribute("interceptedMutationMultipleStudyFilter", mutationMultipleStudyFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromMutationMultipleStudyFilter(mutationMultipleStudyFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of mutationMultipleStudyFilter: " + e); + LOG.error("exception thrown during extraction of mutationMultipleStudyFilter: {}", e.getMessage()); return false; } return true; @@ -466,16 +467,16 @@ private Set extractCancerStudyIdsFromMutationMultipleStudyFilter(Mutatio private boolean extractAttributesFromSampleIdentifiers(HttpServletRequest request) { try { List sampleIdentifiers = Arrays.asList(objectMapper.readValue(request.getInputStream(), SampleIdentifier[].class)); - LOG.debug("extracted sampleIdentifiers: " + sampleIdentifiers.toString()); - LOG.debug("setting interceptedSampleIdentifiers to " + sampleIdentifiers); + LOG.debug("extracted sampleIdentifiers: {}", sampleIdentifiers); + LOG.debug("setting interceptedSampleIdentifiers to {}", sampleIdentifiers); request.setAttribute("interceptedSampleIdentifiers", sampleIdentifiers); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromSampleIdentifiers(sampleIdentifiers); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of sampleIdentifiers: " + e); + LOG.error("exception thrown during extraction of sampleIdentifiers: {}", e.getMessage()); return false; } return true; @@ -485,17 +486,17 @@ private boolean extractAttributesFromClinicalDataBinCountFilter(HttpServletReque try { ClinicalDataBinCountFilter clinicalDataBinCountFilter = objectMapper.readValue(request.getInputStream(), ClinicalDataBinCountFilter.class); - LOG.debug("extracted clinicalDataBinCountFilter: " + clinicalDataBinCountFilter.toString()); - LOG.debug("setting interceptedClinicalDataBinCountFilter to " + clinicalDataBinCountFilter); + LOG.debug("extracted clinicalDataBinCountFilter: {}", clinicalDataBinCountFilter); + LOG.debug("setting interceptedClinicalDataBinCountFilter to {}", clinicalDataBinCountFilter); request.setAttribute("interceptedClinicalDataBinCountFilter", clinicalDataBinCountFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromClinicalDataBinCountFilter( clinicalDataBinCountFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of clinicalDataBinCountFilter: " + e); + LOG.error("exception thrown during extraction of clinicalDataBinCountFilter: {}", e.getMessage()); return false; } return true; @@ -505,17 +506,17 @@ private boolean extractAttributesFromGenomicDataBinCountFilter(HttpServletReques try { GenomicDataBinCountFilter genomicDataBinCountFilter = objectMapper.readValue(request.getInputStream(), GenomicDataBinCountFilter.class); - LOG.debug("extracted genomicDataBinCountFilter: " + genomicDataBinCountFilter.toString()); - LOG.debug("setting interceptedGenomicDataBinCountFilter to " + genomicDataBinCountFilter); + LOG.debug("extracted genomicDataBinCountFilter: {}", genomicDataBinCountFilter); + LOG.debug("setting interceptedGenomicDataBinCountFilter to {}", genomicDataBinCountFilter); request.setAttribute("interceptedGenomicDataBinCountFilter", genomicDataBinCountFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromGenomicDataBinCountFilter( genomicDataBinCountFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of genomicDataBinCountFilter: " + e); + LOG.error("exception thrown during extraction of genomicDataBinCountFilter: {}", e.getMessage()); return false; } return true; @@ -525,17 +526,17 @@ private boolean extractAttributesFromGenomicDataCountFilter(HttpServletRequest r try { GenomicDataCountFilter genomicDataCountFilter = objectMapper.readValue(request.getInputStream(), GenomicDataCountFilter.class); - LOG.debug("extracted genomicDataCountFilter: " + genomicDataCountFilter.toString()); - LOG.debug("setting interceptedGenomicDataCountFilter to " + genomicDataCountFilter); + LOG.debug("extracted genomicDataCountFilter: {}", genomicDataCountFilter); + LOG.debug("setting interceptedGenomicDataCountFilter to {}", genomicDataCountFilter); request.setAttribute("interceptedGenomicDataCountFilter", genomicDataCountFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromGenomicDataCountFilter( genomicDataCountFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of genomicDataCountFilter: " + e); + LOG.error("exception thrown during extraction of genomicDataCountFilter: {}", e.getMessage()); return false; } return true; @@ -545,17 +546,17 @@ private boolean extractAttributesFromGenericAssayDataBinCountFilter(HttpServletR try { GenericAssayDataBinCountFilter genericAssayDataBinCountFilter = objectMapper .readValue(request.getInputStream(), GenericAssayDataBinCountFilter.class); - LOG.debug("extracted genericAssayDataBinCountFilter: " + genericAssayDataBinCountFilter.toString()); - LOG.debug("setting interceptedGenericAssayDataBinCountFilter to " + genericAssayDataBinCountFilter); + LOG.debug("extracted genericAssayDataBinCountFilter: {}", genericAssayDataBinCountFilter); + LOG.debug("setting interceptedGenericAssayDataBinCountFilter to {}", genericAssayDataBinCountFilter); request.setAttribute("interceptedGenericAssayDataBinCountFilter", genericAssayDataBinCountFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromGenericAssayDataBinCountFilter( genericAssayDataBinCountFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of genericAssayDataBinCountFilter: " + e); + LOG.error("exception thrown during extraction of genericAssayDataBinCountFilter: {}", e.getMessage()); return false; } return true; @@ -565,17 +566,17 @@ private boolean extractAttributesFromGenericAssayDataCountFilter(HttpServletRequ try { GenericAssayDataCountFilter genericAssayDataCountFilter = objectMapper .readValue(request.getInputStream(), GenericAssayDataCountFilter.class); - LOG.debug("extracted genericAssayDataCountFilter: " + genericAssayDataCountFilter.toString()); - LOG.debug("setting interceptedGenericAssayDataCountFilter to " + genericAssayDataCountFilter); + LOG.debug("extracted genericAssayDataCountFilter: {}", genericAssayDataCountFilter); + LOG.debug("setting interceptedGenericAssayDataCountFilter to {}", genericAssayDataCountFilter); request.setAttribute("interceptedGenericAssayDataCountFilter", genericAssayDataCountFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromGenericAssayDataCountFilter( genericAssayDataCountFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of genericAssayDataCountFilter: " + e); + LOG.error("exception thrown during extraction of genericAssayDataCountFilter: {}", e.getMessage()); return false; } return true; @@ -585,17 +586,17 @@ private boolean extractAttributesFromClinicalDataCountFilter(HttpServletRequest try { ClinicalDataCountFilter clinicalDataCountFilter = objectMapper.readValue(request.getInputStream(), ClinicalDataCountFilter.class); - LOG.debug("extracted clinicalDataBinCountFilter: " + clinicalDataCountFilter.toString()); - LOG.debug("setting interceptedClinicalDataCountFilter to " + clinicalDataCountFilter); + LOG.debug("extracted clinicalDataBinCountFilter: {}", clinicalDataCountFilter); + LOG.debug("setting interceptedClinicalDataCountFilter to {}", clinicalDataCountFilter); request.setAttribute("interceptedClinicalDataCountFilter", clinicalDataCountFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromClinicalDataCountFilter( clinicalDataCountFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of clinicalDataBinCountFilter: " + e); + LOG.error("exception thrown during extraction of clinicalDataBinCountFilter: {}", e.getMessage()); return false; } return true; @@ -605,18 +606,18 @@ private boolean extractAttributesFromGroupFilter(HttpServletRequest request) { try { GroupFilter groupFilter = objectMapper.readValue(request.getInputStream(), GroupFilter.class); - LOG.debug("extracted groupFilter: " + groupFilter.toString()); - LOG.debug("setting interceptedGroupFilter to " + groupFilter); + LOG.debug("extracted groupFilter: {}", groupFilter); + LOG.debug("setting interceptedGroupFilter to {}", groupFilter); request.setAttribute("interceptedGroupFilter", groupFilter); if (cacheMapUtil.hasCacheEnabled()) { List sampleIdentifiers = groupFilter.getGroups().stream() .flatMap(group -> group.getSampleIdentifiers().stream()).collect(Collectors.toList()); Collection cancerStudyIdCollection = extractCancerStudyIdsFromSampleIdentifiers(sampleIdentifiers); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of groupFilter: " + e); + LOG.error("exception thrown during extraction of groupFilter: {}", e.getMessage()); return false; } return true; @@ -635,16 +636,16 @@ private boolean extractAttributesFromStudyViewFilter(HttpServletRequest request) // when the StructuralVariantFilters are not part of the request. studyViewFilter.setStructuralVariantFilters(new ArrayList<>()); } - LOG.debug("extracted studyViewFilter: " + studyViewFilter.toString()); - LOG.debug("setting interceptedStudyViewFilter to " + studyViewFilter); + LOG.debug("extracted studyViewFilter: {}", studyViewFilter); + LOG.debug("setting interceptedStudyViewFilter to {}", studyViewFilter); request.setAttribute("interceptedStudyViewFilter", studyViewFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromStudyViewFilter(studyViewFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of studyViewFilter: " + e); + LOG.error("exception thrown during extraction of studyViewFilter: {}", e.getMessage()); return false; } return true; @@ -654,17 +655,17 @@ private boolean extractAttributesFromMolecularProfileCasesGroups(HttpServletRequ try { List molecularProfileCasesGroupFilters = Arrays .asList(objectMapper.readValue(request.getInputStream(), MolecularProfileCasesGroupFilter[].class)); - LOG.debug("extracted molecularProfileCasesGroupFilters: " + molecularProfileCasesGroupFilters.toString()); - LOG.debug("setting interceptedMolecularProfileCasesGroupFilters to " + molecularProfileCasesGroupFilters); + LOG.debug("extracted molecularProfileCasesGroupFilters: {}", molecularProfileCasesGroupFilters); + LOG.debug("setting interceptedMolecularProfileCasesGroupFilters to {}", molecularProfileCasesGroupFilters); request.setAttribute("interceptedMolecularProfileCasesGroupFilters", molecularProfileCasesGroupFilters); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromMolecularProfileCasesGroups( molecularProfileCasesGroupFilters); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of molecularProfileCasesGroupFilters: " + e); + LOG.error("exception thrown during extraction of molecularProfileCasesGroupFilters: {}", e.getMessage()); return false; } return true; @@ -674,23 +675,23 @@ private boolean extractAttributesFromMolecularProfileCasesGroupsAndAlterationTyp try { MolecularProfileCasesGroupAndAlterationTypeFilter molecularProfileCasesAndAlterationTypesGroupFilters = objectMapper.readValue(request.getInputStream(), MolecularProfileCasesGroupAndAlterationTypeFilter.class); List molecularProfileCasesGroupFilters = molecularProfileCasesAndAlterationTypesGroupFilters.getMolecularProfileCasesGroupFilter(); - LOG.debug("extracted molecularProfileCasesGroupFilters: " + molecularProfileCasesGroupFilters.toString()); - LOG.debug("setting interceptedMolecularProfileCasesGroupFilters to " + molecularProfileCasesGroupFilters); + LOG.debug("extracted molecularProfileCasesGroupFilters: {}", molecularProfileCasesGroupFilters); + LOG.debug("setting interceptedMolecularProfileCasesGroupFilters to {}", molecularProfileCasesGroupFilters); request.setAttribute("interceptedMolecularProfileCasesGroupFilters", molecularProfileCasesGroupFilters); if (molecularProfileCasesAndAlterationTypesGroupFilters.getAlterationEventTypes() != null) { AlterationFilter alterationEnrichmentEventTypes = molecularProfileCasesAndAlterationTypesGroupFilters.getAlterationEventTypes(); - LOG.debug("extracted alterationEventTypes: " + alterationEnrichmentEventTypes.toString()); - LOG.debug("setting alterationEventTypes to " + alterationEnrichmentEventTypes); + LOG.debug("extracted alterationEventTypes: {}", alterationEnrichmentEventTypes); + LOG.debug("setting alterationEventTypes to {}", alterationEnrichmentEventTypes); request.setAttribute("alterationEventTypes", alterationEnrichmentEventTypes); } if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromMolecularProfileCasesGroups( molecularProfileCasesGroupFilters); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of molecularProfileCasesGroupFilters: " + e); + LOG.error("exception thrown during extraction of molecularProfileCasesGroupFilters: {}", e.getMessage()); return false; } return true; @@ -700,22 +701,22 @@ private boolean extractAttributesFromStructuralVariantFilter(HttpServletRequest try { StructuralVariantFilter structuralVariantFilter = objectMapper.readValue(request.getInputStream(), StructuralVariantFilter.class); - LOG.debug("extracted structuralVariantFilter: " + structuralVariantFilter.toString()); + LOG.debug("extracted structuralVariantFilter: {}", structuralVariantFilter); if (structuralVariantFilter.getStructuralVariantQueries() == null) { // For backwards compatibility an empty set of queries is inferred // when the StructuralVariantFilter is not part of the request. structuralVariantFilter.setStructuralVariantQueries(new ArrayList<>()); } - LOG.debug("setting interceptedStructuralVariantFilter to " + structuralVariantFilter); + LOG.debug("setting interceptedStructuralVariantFilter to {}", structuralVariantFilter); request.setAttribute("interceptedStructuralVariantFilter", structuralVariantFilter); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = extractCancerStudyIdsFromStructuralVariantFilter( structuralVariantFilter); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of structuralVariantFilter: " + e); + LOG.error("exception thrown during extraction of structuralVariantFilter: {}", e.getMessage()); return false; } return true; @@ -841,8 +842,8 @@ private Set extractCancerStudyIdsFromMolecularProfileCasesGroups(Collect private boolean extractCancerStudyIdsFromSurvivalRequest(HttpServletRequest request) { try { SurvivalRequest survivalRequest = objectMapper.readValue(request.getInputStream(), SurvivalRequest.class); - LOG.debug("extracted survivalRequest: " + survivalRequest.toString()); - LOG.debug("setting interceptedSurvivalRequest to " + survivalRequest); + LOG.debug("extracted survivalRequest: {}", survivalRequest); + LOG.debug("setting interceptedSurvivalRequest to {}", survivalRequest); request.setAttribute("interceptedSurvivalRequest", survivalRequest); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = survivalRequest @@ -850,11 +851,11 @@ private boolean extractCancerStudyIdsFromSurvivalRequest(HttpServletRequest requ .stream() .map(PatientIdentifier::getStudyId) .collect(Collectors.toSet()); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of genericAssayDataMultipleStudyFilter: " + e); + LOG.error("exception thrown during extraction of survivalRequest: {}", e.getMessage()); return false; } return true; @@ -863,8 +864,8 @@ private boolean extractCancerStudyIdsFromSurvivalRequest(HttpServletRequest requ private boolean extractCancerStudyIdsFromClinicalEventAttributeRequest(HttpServletRequest request) { try { ClinicalEventAttributeRequest clinicalEventAttributeRequest = objectMapper.readValue(request.getInputStream(), ClinicalEventAttributeRequest.class); - LOG.debug("extracted clinicalEventAttributeRequest: " + clinicalEventAttributeRequest.toString()); - LOG.debug("setting interceptedClinicalEventAttributeRequest to " + clinicalEventAttributeRequest); + LOG.debug("extracted clinicalEventAttributeRequest: {}", clinicalEventAttributeRequest); + LOG.debug("setting interceptedClinicalEventAttributeRequest to {}", clinicalEventAttributeRequest); request.setAttribute("interceptedClinicalEventAttributeRequest", clinicalEventAttributeRequest); if (cacheMapUtil.hasCacheEnabled()) { Collection cancerStudyIdCollection = clinicalEventAttributeRequest @@ -872,11 +873,11 @@ private boolean extractCancerStudyIdsFromClinicalEventAttributeRequest(HttpServl .stream() .map(PatientIdentifier::getStudyId) .collect(Collectors.toSet()); - LOG.debug("setting involvedCancerStudies to " + cancerStudyIdCollection); + LOG.debug("setting involvedCancerStudies to {}", cancerStudyIdCollection); request.setAttribute("involvedCancerStudies", cancerStudyIdCollection); } } catch (Exception e) { - LOG.error("exception thrown during extraction of genericAssayDataMultipleStudyFilter: " + e); + LOG.error("exception thrown during extraction of clinicalEventAttributeRequest: {}", e.getMessage()); return false; } return true; diff --git a/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java b/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java index 814bea5cc08..18d6745801d 100644 --- a/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java +++ b/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java @@ -1,10 +1,5 @@ package org.cbioportal.persistence.mybatis; -import java.util.ArrayList; -import java.util.List; -import java.util.Optional; -import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.databind.ObjectMapper; import org.cbioportal.model.ClinicalEvent; import org.cbioportal.model.ClinicalEventData; import org.cbioportal.model.meta.BaseMeta; @@ -21,11 +16,10 @@ import java.util.Arrays; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; -import static java.util.stream.Collectors.groupingBy; - @RunWith(SpringJUnit4ClassRunner.class) @SpringBootTest(classes = {ClinicalEventMyBatisRepository.class, MolecularProfileCaseIdentifierUtil.class, TestConfig.class}) public class ClinicalEventMyBatisRepositoryTest { @@ -257,9 +251,9 @@ public void getTimelineEvents() { List patientList = new ArrayList<>(); patientList.add("TCGA-A1-A0SD"); - ClinicalEventData clinicalEventData = new ClinicalEventData(); - clinicalEventData.setKey("AGENT"); - clinicalEventData.setValue("Madeupanib"); + ClinicalEventData clinicalEventData1 = new ClinicalEventData(); + clinicalEventData1.setKey("AGENT"); + clinicalEventData1.setValue("Madeupanib"); ClinicalEventData clinicalEventData2 = new ClinicalEventData(); clinicalEventData2.setKey("AGENT"); @@ -267,20 +261,12 @@ public void getTimelineEvents() { ClinicalEvent requestClinicalEvent = new ClinicalEvent(); requestClinicalEvent.setEventType("TREATMENT"); - requestClinicalEvent.setAttributes(Arrays.asList(clinicalEventData, clinicalEventData2)); - List result = clinicalEventMyBatisRepository.getTimelineEvents(studyList, patientList, Arrays.asList(requestClinicalEvent)); - - ObjectMapper mapper = new ObjectMapper(); - try { - System.out.println(mapper.writeValueAsString(result)); - } catch (JsonProcessingException e) { - throw new RuntimeException(e); - } - - Assert.assertEquals("STATUS", "STATUS"); -// List eventTypes = result.stream().map(ClinicalEvent::getEventType).collect(Collectors.toList()); -// Assert.assertEquals(2, result.size()); -// Assert.assertTrue(eventTypes.contains("STATUS")); + requestClinicalEvent.setAttributes(Arrays.asList(clinicalEventData1, clinicalEventData2)); + List result = clinicalEventMyBatisRepository.getTimelineEvents(studyList, patientList, List.of(requestClinicalEvent)); + + Assert.assertEquals(1, result.size()); + Assert.assertEquals((Integer) 213, result.getFirst().getStartDate()); + Assert.assertEquals((Integer) 543, result.getFirst().getStopDate()); } @@ -291,9 +277,9 @@ public void getClinicalEventsMeta() { List patientList = new ArrayList<>(); patientList.add("TCGA-A1-A0SD"); - ClinicalEventData clinicalEventData = new ClinicalEventData(); - clinicalEventData.setKey("AGENT"); - clinicalEventData.setValue("Madeupanib"); + ClinicalEventData clinicalEventData1 = new ClinicalEventData(); + clinicalEventData1.setKey("AGENT"); + clinicalEventData1.setValue("Madeupanib"); ClinicalEventData clinicalEventData2 = new ClinicalEventData(); clinicalEventData2.setKey("AGENT"); @@ -301,19 +287,11 @@ public void getClinicalEventsMeta() { ClinicalEvent requestClinicalEvent = new ClinicalEvent(); requestClinicalEvent.setEventType("TREATMENT"); - requestClinicalEvent.setAttributes(Arrays.asList(clinicalEventData, clinicalEventData2)); - List result = clinicalEventMyBatisRepository.getClinicalEventsMeta(studyList, patientList, Arrays.asList(requestClinicalEvent)); - - ObjectMapper mapper = new ObjectMapper(); - try { - System.out.println(mapper.writeValueAsString(result)); - } catch (JsonProcessingException e) { - throw new RuntimeException(e); - } - - Assert.assertEquals("STATUS", "STATUS"); -// List eventTypes = result.stream().map(ClinicalEvent::getEventType).collect(Collectors.toList()); -// Assert.assertEquals(2, result.size()); -// Assert.assertTrue(eventTypes.contains("STATUS")); + requestClinicalEvent.setAttributes(Arrays.asList(clinicalEventData1, clinicalEventData2)); + List result = clinicalEventMyBatisRepository.getClinicalEventsMeta(studyList, patientList, List.of(requestClinicalEvent)); + + List eventTypes = result.stream().map(ClinicalEvent::getEventType).collect(Collectors.toList()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(eventTypes.contains("treatment")); } } From f6495e8389c2686d4e8a38455b87f9033dfe06c3 Mon Sep 17 00:00:00 2001 From: Qi-Xuan Lu Date: Fri, 10 May 2024 12:24:29 -0400 Subject: [PATCH 09/12] add controller and service tests --- .../org/cbioportal/model/ClinicalData.java | 2 +- .../org/cbioportal/model/SurvivalEvent.java | 7 +- .../impl/ClinicalEventServiceImplTest.java | 182 +++++++++++++++--- .../web/ClinicalEventControllerTest.java | 112 ++++++++++- .../web/SurvivalControllerTest.java | 111 +++++++++++ 5 files changed, 374 insertions(+), 40 deletions(-) create mode 100644 src/test/java/org/cbioportal/web/SurvivalControllerTest.java diff --git a/src/main/java/org/cbioportal/model/ClinicalData.java b/src/main/java/org/cbioportal/model/ClinicalData.java index 553a4b57899..3943de6044f 100644 --- a/src/main/java/org/cbioportal/model/ClinicalData.java +++ b/src/main/java/org/cbioportal/model/ClinicalData.java @@ -52,7 +52,7 @@ public String getAttrId() { } public Boolean isPatientAttribute() { - if(clinicalAttribute == null) { + if (clinicalAttribute == null) { return null; } return this.clinicalAttribute.getPatientAttribute(); diff --git a/src/main/java/org/cbioportal/model/SurvivalEvent.java b/src/main/java/org/cbioportal/model/SurvivalEvent.java index baa2ce94b32..8d26756e572 100644 --- a/src/main/java/org/cbioportal/model/SurvivalEvent.java +++ b/src/main/java/org/cbioportal/model/SurvivalEvent.java @@ -7,6 +7,9 @@ public class SurvivalEvent { List startClinicalEventsMeta; ToIntFunction startPositionIdentifier; List endClinicalEventsMeta; + ToIntFunction endPositionIdentifier; + List censoredClinicalEventsMeta; + ToIntFunction censoredPositionIdentifier; public List getStartClinicalEventsMeta() { return startClinicalEventsMeta; @@ -55,8 +58,4 @@ public ToIntFunction getCensoredPositionIdentifier() { public void setCensoredPositionIdentifier(ToIntFunction censoredPositionIdentifier) { this.censoredPositionIdentifier = censoredPositionIdentifier; } - - ToIntFunction endPositionIdentifier; - List censoredClinicalEventsMeta; - ToIntFunction censoredPositionIdentifier; } diff --git a/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java b/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java index 89a0976c0dc..5de656bdff8 100644 --- a/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java +++ b/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java @@ -1,19 +1,19 @@ package org.cbioportal.service.impl; +import org.cbioportal.model.ClinicalData; import org.cbioportal.model.ClinicalEvent; import org.cbioportal.model.ClinicalEventData; import org.cbioportal.model.ClinicalEventTypeCount; import org.cbioportal.model.Patient; +import org.cbioportal.model.SurvivalEvent; import org.cbioportal.model.meta.BaseMeta; import org.cbioportal.persistence.ClinicalEventRepository; import org.cbioportal.service.PatientService; import org.cbioportal.service.exception.PatientNotFoundException; -import org.junit.Assert; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; import org.mockito.Mock; -import org.mockito.Mockito; import org.mockito.junit.MockitoJUnitRunner; import java.util.ArrayList; @@ -24,11 +24,15 @@ import java.util.Map; import java.util.Set; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.Mockito.when; @RunWith(MockitoJUnitRunner.class) public class ClinicalEventServiceImplTest extends BaseServiceImplTest { - private static final String CLINICAL_EVENT_TYPE = "SERVICE"; + private static final String TEST_CLINICAL_EVENT_TYPE = "SERVICE"; + private static final String TEST_SURVIVAL_PREFIX = "survival_prefix"; @InjectMocks private ClinicalEventServiceImpl clinicalEventService; @@ -46,7 +50,7 @@ public void getAllClinicalEventsOfPatientInStudy() throws Exception { clinicalEvent.setClinicalEventId(CLINICAL_EVENT_ID); expectedClinicalEventList.add(clinicalEvent); - Mockito.when(clinicalEventRepository.getAllClinicalEventsOfPatientInStudy(STUDY_ID, PATIENT_ID_1, PROJECTION, + when(clinicalEventRepository.getAllClinicalEventsOfPatientInStudy(STUDY_ID, PATIENT_ID_1, PROJECTION, PAGE_SIZE, PAGE_NUMBER, SORT, DIRECTION)).thenReturn(expectedClinicalEventList); List expectedClinicalEventDataList = new ArrayList<>(); @@ -54,22 +58,22 @@ public void getAllClinicalEventsOfPatientInStudy() throws Exception { clinicalEventData.setClinicalEventId(CLINICAL_EVENT_ID); expectedClinicalEventDataList.add(clinicalEventData); - Mockito.when(clinicalEventRepository.getDataOfClinicalEvents(Arrays.asList(CLINICAL_EVENT_ID))) + when(clinicalEventRepository.getDataOfClinicalEvents(Arrays.asList(CLINICAL_EVENT_ID))) .thenReturn(expectedClinicalEventDataList); List result = clinicalEventService.getAllClinicalEventsOfPatientInStudy(STUDY_ID, PATIENT_ID_1, PROJECTION, PAGE_SIZE, PAGE_NUMBER, SORT, DIRECTION); - Assert.assertEquals(1, result.size()); - Assert.assertEquals(clinicalEvent, result.get(0)); - Assert.assertEquals(1, result.get(0).getAttributes().size()); - Assert.assertEquals(clinicalEventData, result.get(0).getAttributes().get(0)); + assertEquals(1, result.size()); + assertEquals(clinicalEvent, result.get(0)); + assertEquals(1, result.get(0).getAttributes().size()); + assertEquals(clinicalEventData, result.get(0).getAttributes().get(0)); } @Test(expected = PatientNotFoundException.class) public void getAllClinicalEventsOfPatientInStudyPatientNotFound() throws Exception { - Mockito.when(patientService.getPatientInStudy(STUDY_ID, PATIENT_ID_1)).thenThrow(new PatientNotFoundException( + when(patientService.getPatientInStudy(STUDY_ID, PATIENT_ID_1)).thenThrow(new PatientNotFoundException( STUDY_ID, PATIENT_ID_1)); clinicalEventService.getAllClinicalEventsOfPatientInStudy(STUDY_ID, PATIENT_ID_1, PROJECTION, PAGE_SIZE, PAGE_NUMBER, SORT, DIRECTION); @@ -79,17 +83,17 @@ public void getAllClinicalEventsOfPatientInStudyPatientNotFound() throws Excepti public void getMetaPatientClinicalEvents() throws Exception { BaseMeta expectedBaseMeta = new BaseMeta(); - Mockito.when(clinicalEventRepository.getMetaPatientClinicalEvents(STUDY_ID, PATIENT_ID_1)) + when(clinicalEventRepository.getMetaPatientClinicalEvents(STUDY_ID, PATIENT_ID_1)) .thenReturn(expectedBaseMeta); BaseMeta result = clinicalEventService.getMetaPatientClinicalEvents(STUDY_ID, PATIENT_ID_1); - Assert.assertEquals(expectedBaseMeta, result); + assertEquals(expectedBaseMeta, result); } @Test(expected = PatientNotFoundException.class) public void getMetaPatientClinicalEventsPatientNotFound() throws Exception { - Mockito.when(patientService.getPatientInStudy(STUDY_ID, PATIENT_ID_1)).thenThrow(new PatientNotFoundException( + when(patientService.getPatientInStudy(STUDY_ID, PATIENT_ID_1)).thenThrow(new PatientNotFoundException( STUDY_ID, PATIENT_ID_1)); clinicalEventService.getMetaPatientClinicalEvents(STUDY_ID, PATIENT_ID_1); } @@ -102,7 +106,7 @@ public void getAllClinicalEventsInStudy() throws Exception { clinicalEvent.setClinicalEventId(CLINICAL_EVENT_ID); expectedClinicalEventList.add(clinicalEvent); - Mockito.when(clinicalEventRepository.getAllClinicalEventsInStudy(STUDY_ID, PROJECTION, + when(clinicalEventRepository.getAllClinicalEventsInStudy(STUDY_ID, PROJECTION, PAGE_SIZE, PAGE_NUMBER, SORT, DIRECTION)).thenReturn(expectedClinicalEventList); List expectedClinicalEventDataList = new ArrayList<>(); @@ -110,27 +114,27 @@ public void getAllClinicalEventsInStudy() throws Exception { clinicalEventData.setClinicalEventId(CLINICAL_EVENT_ID); expectedClinicalEventDataList.add(clinicalEventData); - Mockito.when(clinicalEventRepository.getDataOfClinicalEvents(Arrays.asList(CLINICAL_EVENT_ID))) + when(clinicalEventRepository.getDataOfClinicalEvents(Arrays.asList(CLINICAL_EVENT_ID))) .thenReturn(expectedClinicalEventDataList); List result = clinicalEventService.getAllClinicalEventsInStudy(STUDY_ID, PROJECTION, PAGE_SIZE, PAGE_NUMBER, SORT, DIRECTION); - Assert.assertEquals(1, result.size()); - Assert.assertEquals(clinicalEvent, result.get(0)); - Assert.assertEquals(1, result.get(0).getAttributes().size()); - Assert.assertEquals(clinicalEventData, result.get(0).getAttributes().get(0)); + assertEquals(1, result.size()); + assertEquals(clinicalEvent, result.get(0)); + assertEquals(1, result.get(0).getAttributes().size()); + assertEquals(clinicalEventData, result.get(0).getAttributes().get(0)); } @Test public void getMetaClinicalEvents() throws Exception { BaseMeta expectedBaseMeta = new BaseMeta(); - Mockito.when(clinicalEventRepository.getMetaClinicalEvents(STUDY_ID)) + when(clinicalEventRepository.getMetaClinicalEvents(STUDY_ID)) .thenReturn(expectedBaseMeta); BaseMeta result = clinicalEventService.getMetaClinicalEvents(STUDY_ID); - Assert.assertEquals(expectedBaseMeta, result); + assertEquals(expectedBaseMeta, result); } @Test @@ -139,12 +143,12 @@ public void getPatientsSamplesPerClinicalEventType() { List sampleIds = Arrays.asList(SAMPLE_ID1); Map> patientsSamplesPerEventType = new HashMap<>(); - patientsSamplesPerEventType.put(CLINICAL_EVENT_TYPE, new HashSet<>(sampleIds)); + patientsSamplesPerEventType.put(TEST_CLINICAL_EVENT_TYPE, new HashSet<>(sampleIds)); - Mockito.when(clinicalEventRepository.getSamplesOfPatientsPerEventTypeInStudy(anyList(), anyList())) + when(clinicalEventRepository.getSamplesOfPatientsPerEventTypeInStudy(anyList(), anyList())) .thenReturn(patientsSamplesPerEventType); - Assert.assertEquals(patientsSamplesPerEventType, + assertEquals(patientsSamplesPerEventType, clinicalEventService.getPatientsSamplesPerClinicalEventType(studyIds, sampleIds)); } @@ -158,16 +162,136 @@ public void getClinicalEventTypeCounts() { p.setStableId(PATIENT_ID_1); ClinicalEvent ce = new ClinicalEvent(); - ce.setEventType(CLINICAL_EVENT_TYPE); + ce.setEventType(TEST_CLINICAL_EVENT_TYPE); - Mockito.when(patientService.getPatientsOfSamples(anyList(), anyList())) + when(patientService.getPatientsOfSamples(anyList(), anyList())) .thenReturn(Arrays.asList(p)); - Mockito.when(clinicalEventRepository.getPatientsDistinctClinicalEventInStudies(anyList(), anyList())) + when(clinicalEventRepository.getPatientsDistinctClinicalEventInStudies(anyList(), anyList())) .thenReturn(Arrays.asList(ce)); List eventTypeCounts = clinicalEventService.getClinicalEventTypeCounts(studyIds, sampleIds); - Assert.assertEquals(1, eventTypeCounts.size()); + assertEquals(1, eventTypeCounts.size()); int eventTypeCount = eventTypeCounts.get(0).getCount(); - Assert.assertEquals(1, eventTypeCount); + assertEquals(1, eventTypeCount); + } + + @Test + public void getSurvivalDataReturnsCorrectDataWhenEndEventsExist() throws Exception { + List studyIds = List.of(STUDY_ID); + List patientIds = Arrays.asList(PATIENT_ID_1, PATIENT_ID_2, PATIENT_ID_3); + + List clinicalEventList = new ArrayList<>(); + ClinicalEvent clinicalEvent1 = new ClinicalEvent(); + clinicalEvent1.setStudyId(STUDY_ID); + clinicalEvent1.setPatientId(PATIENT_ID_1); + clinicalEvent1.setStartDate(0); + clinicalEvent1.setStopDate(500); + + ClinicalEvent clinicalEvent2 = new ClinicalEvent(); + clinicalEvent2.setStudyId(STUDY_ID); + clinicalEvent2.setPatientId(PATIENT_ID_2); + clinicalEvent2.setStartDate(100); + clinicalEvent2.setStopDate(1000); + + clinicalEventList.add(clinicalEvent1); + clinicalEventList.add(clinicalEvent2); + + SurvivalEvent survivalEvent = new SurvivalEvent(); + survivalEvent.setStartClinicalEventsMeta(clinicalEventList); + survivalEvent.setStartPositionIdentifier(ClinicalEvent::getStartDate); + survivalEvent.setEndClinicalEventsMeta(clinicalEventList); + survivalEvent.setEndPositionIdentifier(ClinicalEvent::getStopDate); + survivalEvent.setCensoredClinicalEventsMeta(clinicalEventList); + survivalEvent.setCensoredPositionIdentifier(ClinicalEvent::getStopDate); + + when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), anyList())) + .thenReturn(Arrays.asList(clinicalEvent1, clinicalEvent2)); + + List result = clinicalEventService.getSurvivalData(studyIds, patientIds, TEST_SURVIVAL_PREFIX, survivalEvent); + + assertEquals(4, result.size()); + assertEquals("survival_prefix_MONTHS", result.get(0).getAttrId()); + assertEquals("16.447368421052634", result.get(0).getAttrValue()); + assertEquals("survival_prefix_STATUS", result.get(1).getAttrId()); + assertEquals("1:EVENT", result.get(1).getAttrValue()); + assertEquals("survival_prefix_MONTHS", result.get(2).getAttrId()); + assertEquals("29.60526315789474", result.get(2).getAttrValue()); + assertEquals("survival_prefix_STATUS", result.get(3).getAttrId()); + assertEquals("1:EVENT", result.get(3).getAttrValue()); + } + + @Test + public void getSurvivalDataReturnsEmptyListWhenNoEventsExist() throws Exception { + List studyIds = List.of(STUDY_ID); + List patientIds = Arrays.asList(PATIENT_ID_1, PATIENT_ID_2, PATIENT_ID_3); + + List clinicalEventList = new ArrayList<>(); + ClinicalEvent clinicalEvent1 = new ClinicalEvent(); + clinicalEvent1.setStudyId(STUDY_ID); + clinicalEvent1.setPatientId(PATIENT_ID_1); + clinicalEvent1.setStartDate(0); + clinicalEvent1.setStopDate(500); + + ClinicalEvent clinicalEvent2 = new ClinicalEvent(); + clinicalEvent2.setStudyId(STUDY_ID); + clinicalEvent2.setPatientId(PATIENT_ID_2); + clinicalEvent2.setStartDate(100); + clinicalEvent2.setStopDate(1000); + + clinicalEventList.add(clinicalEvent1); + clinicalEventList.add(clinicalEvent2); + + SurvivalEvent survivalEvent = new SurvivalEvent(); + survivalEvent.setStartClinicalEventsMeta(clinicalEventList); + survivalEvent.setStartPositionIdentifier(ClinicalEvent::getStartDate); + survivalEvent.setEndClinicalEventsMeta(clinicalEventList); + survivalEvent.setEndPositionIdentifier(ClinicalEvent::getStopDate); + survivalEvent.setCensoredClinicalEventsMeta(clinicalEventList); + survivalEvent.setCensoredPositionIdentifier(ClinicalEvent::getStopDate); + + when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), anyList())) + .thenReturn(new ArrayList<>()); + + List result = clinicalEventService.getSurvivalData(studyIds, patientIds, TEST_SURVIVAL_PREFIX, survivalEvent); + + assertTrue(result.isEmpty()); + } + + @Test + public void getClinicalEventsMetaReturnsCorrectDataForValidInput() throws Exception { + List studyIds = List.of(STUDY_ID); + List patientIds = Arrays.asList(PATIENT_ID_1, PATIENT_ID_2); + List clinicalEvents = new ArrayList<>(); + ClinicalEvent event1 = new ClinicalEvent(); + event1.setStudyId(STUDY_ID); + event1.setPatientId(PATIENT_ID_1); + ClinicalEvent event2 = new ClinicalEvent(); + event2.setStudyId(STUDY_ID); + event2.setPatientId(PATIENT_ID_2); + clinicalEvents.add(event1); + clinicalEvents.add(event2); + + when(clinicalEventRepository.getClinicalEventsMeta(anyList(), anyList(), anyList())).thenReturn(clinicalEvents); + + List result = clinicalEventService.getClinicalEventsMeta(studyIds, patientIds, clinicalEvents); + + assertEquals(2, result.size()); + assertEquals("study_id", result.get(0).getStudyId()); + assertEquals("patient_id1", result.get(0).getPatientId()); + assertEquals("study_id", result.get(1).getStudyId()); + assertEquals("patient_id2", result.get(1).getPatientId()); + } + + @Test + public void getClinicalEventsMetaReturnsEmptyListForInvalidInput() throws Exception { + List studyIds = List.of(STUDY_ID); + List patientIds = Arrays.asList(PATIENT_ID_1, PATIENT_ID_2); + List clinicalEvents = new ArrayList<>(); + + when(clinicalEventRepository.getClinicalEventsMeta(anyList(), anyList(), anyList())).thenReturn(new ArrayList<>()); + + List result = clinicalEventService.getClinicalEventsMeta(studyIds, patientIds, clinicalEvents); + + assertTrue(result.isEmpty()); } } \ No newline at end of file diff --git a/src/test/java/org/cbioportal/web/ClinicalEventControllerTest.java b/src/test/java/org/cbioportal/web/ClinicalEventControllerTest.java index acd87275ada..1576a5c1208 100644 --- a/src/test/java/org/cbioportal/web/ClinicalEventControllerTest.java +++ b/src/test/java/org/cbioportal/web/ClinicalEventControllerTest.java @@ -1,11 +1,14 @@ package org.cbioportal.web; +import com.fasterxml.jackson.databind.ObjectMapper; import org.cbioportal.model.ClinicalEvent; import org.cbioportal.model.ClinicalEventData; import org.cbioportal.model.meta.BaseMeta; import org.cbioportal.service.ClinicalEventService; import org.cbioportal.web.config.TestConfig; +import org.cbioportal.web.parameter.ClinicalEventAttributeRequest; import org.cbioportal.web.parameter.HeaderKeyConstants; +import org.cbioportal.web.parameter.PatientIdentifier; import org.hamcrest.Matchers; import org.junit.Test; import org.junit.runner.RunWith; @@ -22,8 +25,15 @@ import org.springframework.test.web.servlet.result.MockMvcResultMatchers; import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; import java.util.List; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.Mockito.when; +import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf; + @RunWith(SpringJUnit4ClassRunner.class) @WebMvcTest @ContextConfiguration(classes = {ClinicalEventController.class, TestConfig.class}) @@ -48,7 +58,11 @@ public class ClinicalEventControllerTest { private static final String TEST_VALUE_3 = "test_value_3"; private static final String TEST_KEY_4 = "test_key_4"; private static final String TEST_VALUE_4 = "test_value_4"; + private static final String TEST_UNIQUE_PATIENT_KEY_1 = "test_unique_patient_key_1"; + private static final String TEST_UNIQUE_PATIENT_KEY_2 = "test_unique_patient_key_2"; + private final ObjectMapper objectMapper = new ObjectMapper(); + @MockBean private ClinicalEventService clinicalEventService; @@ -61,8 +75,8 @@ public void getAllClinicalEventsOfPatientInStudy() throws Exception { List clinicalEventList = createExampleClinicalEventList(); - Mockito.when(clinicalEventService.getAllClinicalEventsOfPatientInStudy(Mockito.any(), Mockito.any(), - Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())) + when(clinicalEventService.getAllClinicalEventsOfPatientInStudy(any(), any(), + any(), any(), any(), any(), any())) .thenReturn(clinicalEventList); mockMvc.perform(MockMvcRequestBuilders.get("/api/studies/test_study_id/patients/test_patient_id/clinical-events") @@ -99,7 +113,7 @@ public void getAllClinicalEventsOfPatientInStudyMetaProjection() throws Exceptio BaseMeta baseMeta = new BaseMeta(); baseMeta.setTotalCount(2); - Mockito.when(clinicalEventService.getMetaPatientClinicalEvents(Mockito.anyString(), Mockito.anyString())) + when(clinicalEventService.getMetaPatientClinicalEvents(Mockito.anyString(), Mockito.anyString())) .thenReturn(baseMeta); mockMvc.perform(MockMvcRequestBuilders.get("/api/studies/test_study_id/patients/test_patient_id/clinical-events") @@ -114,8 +128,8 @@ public void getAllClinicalEventsInStudy() throws Exception { List clinicalEventList = createExampleClinicalEventList(); - Mockito.when(clinicalEventService.getAllClinicalEventsInStudy(Mockito.any(), - Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())) + when(clinicalEventService.getAllClinicalEventsInStudy(any(), + any(), any(), any(), any(), any())) .thenReturn(clinicalEventList); mockMvc.perform(MockMvcRequestBuilders.get("/api/studies/test_study_id/clinical-events") @@ -152,7 +166,7 @@ public void getAllClinicalEventsInStudyMetaProjection() throws Exception { BaseMeta baseMeta = new BaseMeta(); baseMeta.setTotalCount(2); - Mockito.when(clinicalEventService.getMetaClinicalEvents(Mockito.anyString())) + when(clinicalEventService.getMetaClinicalEvents(Mockito.anyString())) .thenReturn(baseMeta); mockMvc.perform(MockMvcRequestBuilders.get("/api/studies/test_study_id/clinical-events") @@ -161,6 +175,55 @@ public void getAllClinicalEventsInStudyMetaProjection() throws Exception { .andExpect(MockMvcResultMatchers.header().string(HeaderKeyConstants.TOTAL_COUNT, "2")); } + @Test + @WithMockUser + public void fetchClinicalEventsMetaReturnsOkForValidRequest() throws Exception { + List clinicalEventList = createExampleClinicalEventMetaList(); + when(clinicalEventService.getClinicalEventsMeta(anyList(), anyList(), anyList())).thenReturn(clinicalEventList); + + PatientIdentifier patientIdentifier1 = new PatientIdentifier(); + ClinicalEventAttributeRequest clinicalEventAttributeRequest = new ClinicalEventAttributeRequest(); + clinicalEventAttributeRequest.setClinicalEventRequests(new HashSet<>()); + clinicalEventAttributeRequest.setPatientIdentifiers(Collections.singletonList(patientIdentifier1)); + + mockMvc.perform(MockMvcRequestBuilders.post("/api/clinical-events-meta/fetch").with(csrf()) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(clinicalEventAttributeRequest))) + .andExpect(MockMvcResultMatchers.status().isOk()) + .andExpect(MockMvcResultMatchers.content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) + .andExpect(MockMvcResultMatchers.jsonPath("$", Matchers.hasSize(2))) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].clinicalEventId").doesNotExist()) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].eventType").value(TEST_EVENT_TYPE_1)) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].uniquePatientKey").value(TEST_UNIQUE_PATIENT_KEY_1)) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].attributes[0].key").value(TEST_KEY_1)) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].attributes[0].value").value(TEST_VALUE_1)) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].attributes[1].key").value(TEST_KEY_2)) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].attributes[1].value").value(TEST_VALUE_2)) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].clinicalEventId").doesNotExist()) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].eventType").value(TEST_EVENT_TYPE_2)) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].uniquePatientKey").value(TEST_UNIQUE_PATIENT_KEY_2)) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].attributes[0].key").value(TEST_KEY_3)) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].attributes[0].value").value(TEST_VALUE_3)) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].attributes[1].key").value(TEST_KEY_4)) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].attributes[1].value").value(TEST_VALUE_4)); + } + + @Test + @WithMockUser + public void fetchClinicalEventsMetaReturnsBadRequestForInvalidRequest() throws Exception { + + ClinicalEventAttributeRequest clinicalEventAttributeRequest = new ClinicalEventAttributeRequest(); + clinicalEventAttributeRequest.setClinicalEventRequests(new HashSet<>()); + clinicalEventAttributeRequest.setPatientIdentifiers(new ArrayList<>()); + + mockMvc.perform(MockMvcRequestBuilders.post("/api/clinical-events-meta/fetch").with(csrf()) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(clinicalEventAttributeRequest))) + .andExpect(MockMvcResultMatchers.status().isBadRequest()); + } + private final List createExampleClinicalEventList() { List clinicalEventList = new ArrayList<>(); ClinicalEvent clinicalEvent1 = new ClinicalEvent(); @@ -205,4 +268,41 @@ private final List createExampleClinicalEventList() { clinicalEventList.add(clinicalEvent2); return clinicalEventList; } + + private final List createExampleClinicalEventMetaList() { + List clinicalEventList = new ArrayList<>(); + ClinicalEvent clinicalEvent1 = new ClinicalEvent(); + clinicalEvent1.setUniquePatientKey(TEST_UNIQUE_PATIENT_KEY_1); + clinicalEvent1.setEventType(TEST_EVENT_TYPE_1); + List clinicalEventDataList1 = new ArrayList<>(); + ClinicalEventData clinicalEventData1 = new ClinicalEventData(); + clinicalEventData1.setClinicalEventId(TEST_CLINICAL_EVENT_ID_1); + clinicalEventData1.setKey(TEST_KEY_1); + clinicalEventData1.setValue(TEST_VALUE_1); + clinicalEventDataList1.add(clinicalEventData1); + ClinicalEventData clinicalEventData2 = new ClinicalEventData(); + clinicalEventData2.setClinicalEventId(TEST_CLINICAL_EVENT_ID_1); + clinicalEventData2.setKey(TEST_KEY_2); + clinicalEventData2.setValue(TEST_VALUE_2); + clinicalEventDataList1.add(clinicalEventData2); + clinicalEvent1.setAttributes(clinicalEventDataList1); + clinicalEventList.add(clinicalEvent1); + ClinicalEvent clinicalEvent2 = new ClinicalEvent(); + clinicalEvent2.setUniquePatientKey(TEST_UNIQUE_PATIENT_KEY_2); + clinicalEvent2.setEventType(TEST_EVENT_TYPE_2); + List clinicalEventDataList2 = new ArrayList<>(); + ClinicalEventData clinicalEventData3 = new ClinicalEventData(); + clinicalEventData3.setClinicalEventId(TEST_CLINICAL_EVENT_ID_2); + clinicalEventData3.setKey(TEST_KEY_3); + clinicalEventData3.setValue(TEST_VALUE_3); + clinicalEventDataList2.add(clinicalEventData3); + ClinicalEventData clinicalEventData4 = new ClinicalEventData(); + clinicalEventData4.setClinicalEventId(TEST_CLINICAL_EVENT_ID_2); + clinicalEventData4.setKey(TEST_KEY_4); + clinicalEventData4.setValue(TEST_VALUE_4); + clinicalEventDataList2.add(clinicalEventData4); + clinicalEvent2.setAttributes(clinicalEventDataList2); + clinicalEventList.add(clinicalEvent2); + return clinicalEventList; + } } diff --git a/src/test/java/org/cbioportal/web/SurvivalControllerTest.java b/src/test/java/org/cbioportal/web/SurvivalControllerTest.java new file mode 100644 index 00000000000..8bf8c066a6f --- /dev/null +++ b/src/test/java/org/cbioportal/web/SurvivalControllerTest.java @@ -0,0 +1,111 @@ +package org.cbioportal.web; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.cbioportal.model.ClinicalData; +import org.cbioportal.service.ClinicalEventService; +import org.cbioportal.web.config.TestConfig; +import org.cbioportal.web.parameter.ClinicalEventRequestIdentifier; +import org.cbioportal.web.parameter.OccurrencePosition; +import org.cbioportal.web.parameter.PatientIdentifier; +import org.cbioportal.web.parameter.SurvivalRequest; +import org.hamcrest.Matchers; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.http.MediaType; +import org.springframework.security.test.context.support.WithMockUser; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; +import org.springframework.test.web.servlet.result.MockMvcResultMatchers; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.Mockito.when; +import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf; + +@RunWith(SpringJUnit4ClassRunner.class) +@WebMvcTest +@ContextConfiguration(classes = {SurvivalController.class, TestConfig.class}) +public class SurvivalControllerTest { + + private static final String TEST_CANCER_STUDY_IDENTIFIER = "test_study_id"; + private static final String TEST_PATIENT_ID_1 = "test_patient_id_1"; + private static final String TEST_PATIENT_ID_2 = "test_patient_id_2"; + private static final String TEST_ATTRIBUTE_ID_PREFIX = "test_attribute_id_prefix"; + private static final String TEST_CLINICAL_ATTRIBUTE_ID_1 = "test_clinical_attribute_id_1"; + private static final String TEST_CLINICAL_ATTRIBUTE_ID_2 = "test_clinical_attribute_id_2"; + private static final String TEST_CLINICAL_ATTRIBUTE_VALUE_1 = "test_clinical_attribute_value_1"; + private static final String TEST_CLINICAL_ATTRIBUTE_VALUE_2 = "test_clinical_attribute_value_2"; + + private final ObjectMapper objectMapper = new ObjectMapper(); + + @MockBean + private ClinicalEventService clinicalEventService; + + @Autowired + private MockMvc mockMvc; + + @Test + @WithMockUser + public void fetchSurvivalData() throws Exception { + List clinicalDataList = createClinicalDataList(); + when(clinicalEventService.getSurvivalData(anyList(), anyList(), any(), any())) + .thenReturn(clinicalDataList); + + SurvivalRequest survivalRequest = new SurvivalRequest(); + PatientIdentifier patientIdentifier = new PatientIdentifier(); + patientIdentifier.setPatientId(TEST_PATIENT_ID_1); + patientIdentifier.setStudyId(TEST_CANCER_STUDY_IDENTIFIER); + survivalRequest.setPatientIdentifiers(List.of(patientIdentifier)); + survivalRequest.setAttributeIdPrefix(TEST_ATTRIBUTE_ID_PREFIX); + + ClinicalEventRequestIdentifier startEventRequestIdentifier = new ClinicalEventRequestIdentifier(); + startEventRequestIdentifier.setClinicalEventRequests(new HashSet<>()); + startEventRequestIdentifier.setPosition(OccurrencePosition.FIRST); + survivalRequest.setStartEventRequestIdentifier(startEventRequestIdentifier); + + mockMvc.perform(MockMvcRequestBuilders.post("/api/survival-data/fetch").with(csrf()) + .accept(MediaType.APPLICATION_JSON) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(survivalRequest))) + .andExpect(MockMvcResultMatchers.status().isOk()) + .andExpect(MockMvcResultMatchers.content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) + .andExpect(MockMvcResultMatchers.jsonPath("$", Matchers.hasSize(2))) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].studyId").value(TEST_CANCER_STUDY_IDENTIFIER)) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].patientId").value(TEST_PATIENT_ID_1)) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].clinicalAttributeId").value(TEST_CLINICAL_ATTRIBUTE_ID_1)) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].value").value(TEST_CLINICAL_ATTRIBUTE_VALUE_1)) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].studyId").value(TEST_CANCER_STUDY_IDENTIFIER)) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].patientId").value(TEST_PATIENT_ID_2)) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].clinicalAttributeId").value(TEST_CLINICAL_ATTRIBUTE_ID_2)) + .andExpect(MockMvcResultMatchers.jsonPath("$[1].value").value(TEST_CLINICAL_ATTRIBUTE_VALUE_2)); + } + + private List createClinicalDataList() { + List clinicalDataList = new ArrayList<>(); + + ClinicalData clinicalData1 = new ClinicalData(); + clinicalData1.setStudyId(TEST_CANCER_STUDY_IDENTIFIER); + clinicalData1.setPatientId(TEST_PATIENT_ID_1); + clinicalData1.setAttrId(TEST_CLINICAL_ATTRIBUTE_ID_1); + clinicalData1.setAttrValue(TEST_CLINICAL_ATTRIBUTE_VALUE_1); + clinicalDataList.add(clinicalData1); + + ClinicalData clinicalData2 = new ClinicalData(); + clinicalData2.setStudyId(TEST_CANCER_STUDY_IDENTIFIER); + clinicalData2.setPatientId(TEST_PATIENT_ID_2); + clinicalData2.setAttrId(TEST_CLINICAL_ATTRIBUTE_ID_2); + clinicalData2.setAttrValue(TEST_CLINICAL_ATTRIBUTE_VALUE_2); + clinicalDataList.add(clinicalData2); + + return clinicalDataList; + } +} From 2fb75ee4719175b3223b120ec6fcb60eb3503361 Mon Sep 17 00:00:00 2001 From: Qi-Xuan Lu Date: Mon, 13 May 2024 16:07:00 -0400 Subject: [PATCH 10/12] increase test coverage --- .../impl/ClinicalEventServiceImplTest.java | 61 +++++++++++++++---- .../web/ClinicalEventControllerTest.java | 7 ++- .../web/SurvivalControllerTest.java | 21 ++++++- 3 files changed, 75 insertions(+), 14 deletions(-) diff --git a/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java b/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java index 5de656bdff8..9b19435f82e 100644 --- a/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java +++ b/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java @@ -27,6 +27,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.when; @RunWith(MockitoJUnitRunner.class) @@ -180,7 +181,7 @@ public void getSurvivalDataReturnsCorrectDataWhenEndEventsExist() throws Excepti List studyIds = List.of(STUDY_ID); List patientIds = Arrays.asList(PATIENT_ID_1, PATIENT_ID_2, PATIENT_ID_3); - List clinicalEventList = new ArrayList<>(); + List startClinicalEvents = new ArrayList<>(); ClinicalEvent clinicalEvent1 = new ClinicalEvent(); clinicalEvent1.setStudyId(STUDY_ID); clinicalEvent1.setPatientId(PATIENT_ID_1); @@ -192,32 +193,70 @@ public void getSurvivalDataReturnsCorrectDataWhenEndEventsExist() throws Excepti clinicalEvent2.setPatientId(PATIENT_ID_2); clinicalEvent2.setStartDate(100); clinicalEvent2.setStopDate(1000); + + ClinicalEvent clinicalEvent3 = new ClinicalEvent(); + clinicalEvent3.setStudyId(STUDY_ID); + clinicalEvent3.setPatientId(PATIENT_ID_3); + clinicalEvent3.setStartDate(1000); + clinicalEvent3.setStopDate(1200); - clinicalEventList.add(clinicalEvent1); - clinicalEventList.add(clinicalEvent2); + startClinicalEvents.add(clinicalEvent1); + startClinicalEvents.add(clinicalEvent2); + startClinicalEvents.add(clinicalEvent3); + + List endClinicalEvents = new ArrayList<>(); + ClinicalEvent clinicalEvent4 = new ClinicalEvent(); + clinicalEvent4.setStudyId(STUDY_ID); + clinicalEvent4.setPatientId(PATIENT_ID_1); + clinicalEvent4.setStartDate(500); + clinicalEvent4.setStopDate(1000); + + endClinicalEvents.add(clinicalEvent4); + + List censoredClinicalEvents = new ArrayList<>(); + ClinicalEvent clinicalEvent5 = new ClinicalEvent(); + clinicalEvent5.setStudyId(STUDY_ID); + clinicalEvent5.setPatientId(PATIENT_ID_2); + clinicalEvent5.setStartDate(1000); + clinicalEvent5.setStopDate(2000); + + ClinicalEvent clinicalEvent6 = new ClinicalEvent(); + clinicalEvent6.setStudyId(STUDY_ID); + clinicalEvent6.setPatientId(PATIENT_ID_3); + clinicalEvent6.setStartDate(600); + clinicalEvent6.setStopDate(1000); + + censoredClinicalEvents.add(clinicalEvent5); + censoredClinicalEvents.add(clinicalEvent6); SurvivalEvent survivalEvent = new SurvivalEvent(); - survivalEvent.setStartClinicalEventsMeta(clinicalEventList); + survivalEvent.setStartClinicalEventsMeta(startClinicalEvents); survivalEvent.setStartPositionIdentifier(ClinicalEvent::getStartDate); - survivalEvent.setEndClinicalEventsMeta(clinicalEventList); + survivalEvent.setEndClinicalEventsMeta(endClinicalEvents); survivalEvent.setEndPositionIdentifier(ClinicalEvent::getStopDate); - survivalEvent.setCensoredClinicalEventsMeta(clinicalEventList); + survivalEvent.setCensoredClinicalEventsMeta(censoredClinicalEvents); survivalEvent.setCensoredPositionIdentifier(ClinicalEvent::getStopDate); - when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), anyList())) - .thenReturn(Arrays.asList(clinicalEvent1, clinicalEvent2)); + when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), eq(startClinicalEvents))) + .thenReturn(startClinicalEvents); + when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), eq(endClinicalEvents))) + .thenReturn(endClinicalEvents); + when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), eq(censoredClinicalEvents))) + .thenReturn(censoredClinicalEvents); List result = clinicalEventService.getSurvivalData(studyIds, patientIds, TEST_SURVIVAL_PREFIX, survivalEvent); assertEquals(4, result.size()); + assertEquals(PATIENT_ID_1, result.getFirst().getPatientId()); assertEquals("survival_prefix_MONTHS", result.get(0).getAttrId()); - assertEquals("16.447368421052634", result.get(0).getAttrValue()); + assertEquals("32.89473684210527", result.get(0).getAttrValue()); assertEquals("survival_prefix_STATUS", result.get(1).getAttrId()); assertEquals("1:EVENT", result.get(1).getAttrValue()); + assertEquals(PATIENT_ID_2, result.get(2).getPatientId()); assertEquals("survival_prefix_MONTHS", result.get(2).getAttrId()); - assertEquals("29.60526315789474", result.get(2).getAttrValue()); + assertEquals("62.5", result.get(2).getAttrValue()); assertEquals("survival_prefix_STATUS", result.get(3).getAttrId()); - assertEquals("1:EVENT", result.get(3).getAttrValue()); + assertEquals("0:CENSORED", result.get(3).getAttrValue()); } @Test diff --git a/src/test/java/org/cbioportal/web/ClinicalEventControllerTest.java b/src/test/java/org/cbioportal/web/ClinicalEventControllerTest.java index 1576a5c1208..bdbda3ca306 100644 --- a/src/test/java/org/cbioportal/web/ClinicalEventControllerTest.java +++ b/src/test/java/org/cbioportal/web/ClinicalEventControllerTest.java @@ -7,6 +7,7 @@ import org.cbioportal.service.ClinicalEventService; import org.cbioportal.web.config.TestConfig; import org.cbioportal.web.parameter.ClinicalEventAttributeRequest; +import org.cbioportal.web.parameter.ClinicalEventRequest; import org.cbioportal.web.parameter.HeaderKeyConstants; import org.cbioportal.web.parameter.PatientIdentifier; import org.hamcrest.Matchers; @@ -28,6 +29,7 @@ import java.util.Collections; import java.util.HashSet; import java.util.List; +import java.util.Set; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyList; @@ -183,7 +185,10 @@ public void fetchClinicalEventsMetaReturnsOkForValidRequest() throws Exception { PatientIdentifier patientIdentifier1 = new PatientIdentifier(); ClinicalEventAttributeRequest clinicalEventAttributeRequest = new ClinicalEventAttributeRequest(); - clinicalEventAttributeRequest.setClinicalEventRequests(new HashSet<>()); + ClinicalEventRequest clinicalEventRequest = new ClinicalEventRequest(); + clinicalEventRequest.setEventType(TEST_EVENT_TYPE_1); + clinicalEventRequest.setAttributes(new ArrayList<>()); + clinicalEventAttributeRequest.setClinicalEventRequests(Set.of(clinicalEventRequest)); clinicalEventAttributeRequest.setPatientIdentifiers(Collections.singletonList(patientIdentifier1)); mockMvc.perform(MockMvcRequestBuilders.post("/api/clinical-events-meta/fetch").with(csrf()) diff --git a/src/test/java/org/cbioportal/web/SurvivalControllerTest.java b/src/test/java/org/cbioportal/web/SurvivalControllerTest.java index 8bf8c066a6f..7c8532c515d 100644 --- a/src/test/java/org/cbioportal/web/SurvivalControllerTest.java +++ b/src/test/java/org/cbioportal/web/SurvivalControllerTest.java @@ -4,6 +4,7 @@ import org.cbioportal.model.ClinicalData; import org.cbioportal.service.ClinicalEventService; import org.cbioportal.web.config.TestConfig; +import org.cbioportal.web.parameter.ClinicalEventRequest; import org.cbioportal.web.parameter.ClinicalEventRequestIdentifier; import org.cbioportal.web.parameter.OccurrencePosition; import org.cbioportal.web.parameter.PatientIdentifier; @@ -23,8 +24,8 @@ import org.springframework.test.web.servlet.result.MockMvcResultMatchers; import java.util.ArrayList; -import java.util.HashSet; import java.util.List; +import java.util.Set; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyList; @@ -44,6 +45,8 @@ public class SurvivalControllerTest { private static final String TEST_CLINICAL_ATTRIBUTE_ID_2 = "test_clinical_attribute_id_2"; private static final String TEST_CLINICAL_ATTRIBUTE_VALUE_1 = "test_clinical_attribute_value_1"; private static final String TEST_CLINICAL_ATTRIBUTE_VALUE_2 = "test_clinical_attribute_value_2"; + private static final String TEST_CLINICAL_EVENT_TYPE = "test_clinical_event_type"; + private final ObjectMapper objectMapper = new ObjectMapper(); @@ -67,10 +70,24 @@ public void fetchSurvivalData() throws Exception { survivalRequest.setPatientIdentifiers(List.of(patientIdentifier)); survivalRequest.setAttributeIdPrefix(TEST_ATTRIBUTE_ID_PREFIX); + ClinicalEventRequest clinicalEventRequest = new ClinicalEventRequest(); + clinicalEventRequest.setEventType(TEST_CLINICAL_EVENT_TYPE); + clinicalEventRequest.setAttributes(new ArrayList<>()); + ClinicalEventRequestIdentifier startEventRequestIdentifier = new ClinicalEventRequestIdentifier(); - startEventRequestIdentifier.setClinicalEventRequests(new HashSet<>()); + startEventRequestIdentifier.setClinicalEventRequests(Set.of(clinicalEventRequest)); startEventRequestIdentifier.setPosition(OccurrencePosition.FIRST); survivalRequest.setStartEventRequestIdentifier(startEventRequestIdentifier); + + ClinicalEventRequestIdentifier endEventRequestIdentifier = new ClinicalEventRequestIdentifier(); + endEventRequestIdentifier.setClinicalEventRequests(Set.of(clinicalEventRequest)); + endEventRequestIdentifier.setPosition(OccurrencePosition.LAST); + survivalRequest.setEndEventRequestIdentifier(endEventRequestIdentifier); + + ClinicalEventRequestIdentifier censoredEventRequestIdentifier = new ClinicalEventRequestIdentifier(); + censoredEventRequestIdentifier.setClinicalEventRequests(Set.of(clinicalEventRequest)); + censoredEventRequestIdentifier.setPosition(OccurrencePosition.LAST); + survivalRequest.setCensoredEventRequestIdentifier(censoredEventRequestIdentifier); mockMvc.perform(MockMvcRequestBuilders.post("/api/survival-data/fetch").with(csrf()) .accept(MediaType.APPLICATION_JSON) From 776acf027914c6b711c2b412012cda08333cc291 Mon Sep 17 00:00:00 2001 From: Qi-Xuan Lu Date: Wed, 5 Jun 2024 15:47:42 -0400 Subject: [PATCH 11/12] refactor getSurvivalData and udpate tests --- .../org/cbioportal/model/ClinicalEvent.java | 14 ++ .../org/cbioportal/model/SurvivalEvent.java | 61 ------- .../service/ClinicalEventService.java | 4 +- .../impl/ClinicalEventServiceImpl.java | 164 +++++++++++------- .../cbioportal/web/SurvivalController.java | 43 +---- .../impl/ClinicalEventServiceImplTest.java | 116 ++++++++++--- 6 files changed, 208 insertions(+), 194 deletions(-) delete mode 100644 src/main/java/org/cbioportal/model/SurvivalEvent.java diff --git a/src/main/java/org/cbioportal/model/ClinicalEvent.java b/src/main/java/org/cbioportal/model/ClinicalEvent.java index e8ceb4def4e..c98a7ea95f0 100644 --- a/src/main/java/org/cbioportal/model/ClinicalEvent.java +++ b/src/main/java/org/cbioportal/model/ClinicalEvent.java @@ -3,6 +3,7 @@ import jakarta.validation.constraints.NotNull; import java.util.List; +import java.util.Objects; public class ClinicalEvent extends UniqueKeyBase { @@ -72,4 +73,17 @@ public List getAttributes() { public void setAttributes(List attributes) { this.attributes = attributes; } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ClinicalEvent that = (ClinicalEvent) o; + return Objects.equals(clinicalEventId, that.clinicalEventId) && Objects.equals(studyId, that.studyId) && Objects.equals(patientId, that.patientId) && Objects.equals(eventType, that.eventType) && Objects.equals(startDate, that.startDate) && Objects.equals(stopDate, that.stopDate) && Objects.equals(attributes, that.attributes); + } + + @Override + public int hashCode() { + return Objects.hash(clinicalEventId, studyId, patientId, eventType, startDate, stopDate, attributes); + } } diff --git a/src/main/java/org/cbioportal/model/SurvivalEvent.java b/src/main/java/org/cbioportal/model/SurvivalEvent.java deleted file mode 100644 index 8d26756e572..00000000000 --- a/src/main/java/org/cbioportal/model/SurvivalEvent.java +++ /dev/null @@ -1,61 +0,0 @@ -package org.cbioportal.model; - -import java.util.List; -import java.util.function.ToIntFunction; - -public class SurvivalEvent { - List startClinicalEventsMeta; - ToIntFunction startPositionIdentifier; - List endClinicalEventsMeta; - ToIntFunction endPositionIdentifier; - List censoredClinicalEventsMeta; - ToIntFunction censoredPositionIdentifier; - - public List getStartClinicalEventsMeta() { - return startClinicalEventsMeta; - } - - public void setStartClinicalEventsMeta(List startClinicalEventsMeta) { - this.startClinicalEventsMeta = startClinicalEventsMeta; - } - - public ToIntFunction getStartPositionIdentifier() { - return startPositionIdentifier; - } - - public void setStartPositionIdentifier(ToIntFunction startPositionIdentifier) { - this.startPositionIdentifier = startPositionIdentifier; - } - - public List getEndClinicalEventsMeta() { - return endClinicalEventsMeta; - } - - public void setEndClinicalEventsMeta(List endClinicalEventsMeta) { - this.endClinicalEventsMeta = endClinicalEventsMeta; - } - - public ToIntFunction getEndPositionIdentifier() { - return endPositionIdentifier; - } - - public void setEndPositionIdentifier(ToIntFunction endPositionIdentifier) { - this.endPositionIdentifier = endPositionIdentifier; - } - - public List getCensoredClinicalEventsMeta() { - return censoredClinicalEventsMeta; - } - - public void setCensoredClinicalEventsMeta(List censoredClinicalEventsMeta) { - this.censoredClinicalEventsMeta = censoredClinicalEventsMeta; - } - - public ToIntFunction getCensoredPositionIdentifier() { - return censoredPositionIdentifier; - } - - public void setCensoredPositionIdentifier(ToIntFunction censoredPositionIdentifier) { - this.censoredPositionIdentifier = censoredPositionIdentifier; - } -} diff --git a/src/main/java/org/cbioportal/service/ClinicalEventService.java b/src/main/java/org/cbioportal/service/ClinicalEventService.java index e542d512517..ad0009ac0b6 100644 --- a/src/main/java/org/cbioportal/service/ClinicalEventService.java +++ b/src/main/java/org/cbioportal/service/ClinicalEventService.java @@ -3,10 +3,10 @@ import org.cbioportal.model.ClinicalData; import org.cbioportal.model.ClinicalEvent; import org.cbioportal.model.ClinicalEventTypeCount; -import org.cbioportal.model.SurvivalEvent; import org.cbioportal.model.meta.BaseMeta; import org.cbioportal.service.exception.PatientNotFoundException; import org.cbioportal.service.exception.StudyNotFoundException; +import org.cbioportal.web.parameter.SurvivalRequest; import java.util.List; import java.util.Map; @@ -34,7 +34,7 @@ BaseMeta getMetaClinicalEvents(String studyId) List getSurvivalData(List studyIds, List patientIds, String attributeIdPrefix, - SurvivalEvent survivalEvent); + SurvivalRequest survivalRequest); List getClinicalEventsMeta(List studyIds, List patientIds, List clinicalEvents); diff --git a/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java b/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java index 2ffd2520352..6a00c9c060d 100644 --- a/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java +++ b/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java @@ -6,13 +6,15 @@ import org.cbioportal.model.ClinicalEventData; import org.cbioportal.model.ClinicalEventTypeCount; import org.cbioportal.model.Patient; -import org.cbioportal.model.SurvivalEvent; import org.cbioportal.model.meta.BaseMeta; import org.cbioportal.persistence.ClinicalEventRepository; import org.cbioportal.service.ClinicalEventService; import org.cbioportal.service.PatientService; import org.cbioportal.service.exception.PatientNotFoundException; import org.cbioportal.service.exception.StudyNotFoundException; +import org.cbioportal.web.parameter.ClinicalEventRequestIdentifier; +import org.cbioportal.web.parameter.OccurrencePosition; +import org.cbioportal.web.parameter.SurvivalRequest; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @@ -127,29 +129,15 @@ public List getClinicalEventTypeCounts(List stud public List getSurvivalData(List studyIds, List patientIds, String attributeIdPrefix, - SurvivalEvent survivalEvent) { - List startClinicalEventsMeta = survivalEvent.getStartClinicalEventsMeta(); - ToIntFunction startPositionIdentifier = survivalEvent.getStartPositionIdentifier(); - List endClinicalEventsMeta = survivalEvent.getEndClinicalEventsMeta(); - ToIntFunction endPositionIdentifier = survivalEvent.getEndPositionIdentifier(); - List censoredClinicalEventsMeta = survivalEvent.getCensoredClinicalEventsMeta(); - ToIntFunction censoredPositionIdentifier = survivalEvent.getCensoredPositionIdentifier(); - + SurvivalRequest survivalRequest) { + List startClinicalEventsMeta = getToClinicalEvents(survivalRequest.getStartEventRequestIdentifier()); List patientStartEvents = clinicalEventRepository.getTimelineEvents(studyIds, patientIds, startClinicalEventsMeta); - List filteredStudyIds = new ArrayList<>(); - List filteredPatientIds = new ArrayList<>(); - for (ClinicalEvent clinicalEvent : patientStartEvents) { - filteredStudyIds.add(clinicalEvent.getStudyId()); - filteredPatientIds.add(clinicalEvent.getPatientId()); - } - // only fetch end timeline events for patients that have endClinicalEventsMeta and start timeline events - List patientEndEvents = new ArrayList<>(); - if (CollectionUtils.isNotEmpty(endClinicalEventsMeta) && CollectionUtils.isNotEmpty(filteredStudyIds)) { - patientEndEvents = clinicalEventRepository.getTimelineEvents(filteredStudyIds, filteredPatientIds, endClinicalEventsMeta); - } + List patientEndEvents = filterClinicalEvents(patientStartEvents, survivalRequest.getEndEventRequestIdentifier()); + ToIntFunction startPositionIdentifier = getPositionIdentifier(survivalRequest.getStartEventRequestIdentifier().getPosition()); + ToIntFunction endPositionIdentifier = getPositionIdentifier(survivalRequest.getEndEventRequestIdentifier().getPosition()); Map patientEndEventsById = patientEndEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); // filter out cases where start event is less than end event @@ -159,53 +147,15 @@ public List getSurvivalData(List studyIds, .map(endPositionIdentifier::applyAsInt) .map(endDate -> startPositionIdentifier.applyAsInt(event) < endDate) .orElse(true) - ).toList(); - - filteredStudyIds.clear(); - filteredPatientIds.clear(); - // get all the studies that have start events but not end events - for (ClinicalEvent clinicalEvent : patientStartEvents.stream().filter(event -> !patientEndEventsById.containsKey(getKey(event))).toList()) { - filteredStudyIds.add(clinicalEvent.getStudyId()); - filteredPatientIds.add(clinicalEvent.getPatientId()); - } + ).collect(Collectors.toList()); - List patientCensoredEvents = new ArrayList<>(); - if (CollectionUtils.isNotEmpty(filteredStudyIds)) { - patientCensoredEvents = clinicalEventRepository.getTimelineEvents(filteredStudyIds, filteredPatientIds, censoredClinicalEventsMeta); - } - - Map patientCensoredEventsById = patientCensoredEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); + List patientCensoredEvents = filterClinicalEvents(patientStartEvents, survivalRequest.getCensoredEventRequestIdentifier()); return patientStartEvents.stream() .flatMap(event -> { - ClinicalData clinicalDataMonths = new ClinicalData(); - clinicalDataMonths.setStudyId(event.getStudyId()); - clinicalDataMonths.setPatientId(event.getPatientId()); - clinicalDataMonths.setAttrId(attributeIdPrefix + "_MONTHS"); - - ClinicalData clinicalDataStatus = new ClinicalData(); - clinicalDataStatus.setStudyId(event.getStudyId()); - clinicalDataStatus.setPatientId(event.getPatientId()); - clinicalDataStatus.setAttrId(attributeIdPrefix + "_STATUS"); - - int startDate = startPositionIdentifier.applyAsInt(event); - int endDate; - if (patientEndEventsById.containsKey(getKey(event))) { - clinicalDataStatus.setAttrValue("1:EVENT"); - endDate = endPositionIdentifier.applyAsInt(patientEndEventsById.get(getKey(event))); - } else { - // ignore cases where patient does not have censored timeline events or - // stop date of start event is less than start date of censored events - if (!patientCensoredEventsById.containsKey(getKey(event)) || - startDate >= censoredPositionIdentifier.applyAsInt(patientCensoredEventsById.get(getKey(event))) - ) { - return Stream.empty(); - } - - clinicalDataStatus.setAttrValue("0:CENSORED"); - endDate = censoredPositionIdentifier.applyAsInt(patientCensoredEventsById.get(getKey(event))); - } - clinicalDataMonths.setAttrValue(String.valueOf((endDate - startDate) / 30.4)); + ClinicalData clinicalDataMonths = buildClinicalSurvivalMonths(attributeIdPrefix, event, survivalRequest, patientEndEvents, patientCensoredEvents); + if (clinicalDataMonths == null) return Stream.empty(); + ClinicalData clinicalDataStatus = buildClinicalSurvivalStatus(attributeIdPrefix, event, patientEndEvents); return Stream.of(clinicalDataMonths, clinicalDataStatus); }).toList(); @@ -219,4 +169,92 @@ public List getClinicalEventsMeta(List studyIds, List getToClinicalEvents(ClinicalEventRequestIdentifier clinicalEventRequestIdentifier) { + return clinicalEventRequestIdentifier.getClinicalEventRequests().stream().map(x -> { + ClinicalEvent clinicalEvent = new ClinicalEvent(); + clinicalEvent.setEventType(x.getEventType()); + clinicalEvent.setAttributes(x.getAttributes()); + + return clinicalEvent; + }).collect(Collectors.toList()); + } + + private ToIntFunction getPositionIdentifier(OccurrencePosition position) { + return position.equals(OccurrencePosition.FIRST) ? ClinicalEvent::getStartDate : ClinicalEvent::getStopDate; + } + + private List filterClinicalEvents(List patientEvents, + ClinicalEventRequestIdentifier clinicalEventRequestIdentifier) { + List filteredStudyIds = new ArrayList<>(); + List filteredPatientIds = new ArrayList<>(); + for (ClinicalEvent clinicalEvent : patientEvents) { + filteredStudyIds.add(clinicalEvent.getStudyId()); + filteredPatientIds.add(clinicalEvent.getPatientId()); + } + + List clinicalEventsMeta = new ArrayList<>(); + if (clinicalEventRequestIdentifier != null) { + clinicalEventsMeta = getToClinicalEvents(clinicalEventRequestIdentifier); + } + + // only fetch end timeline events for patients that have endClinicalEventsMeta and start timeline events + List queriedPatientEvents = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(clinicalEventsMeta) && CollectionUtils.isNotEmpty(filteredStudyIds)) { + queriedPatientEvents = clinicalEventRepository.getTimelineEvents(filteredStudyIds, filteredPatientIds, clinicalEventsMeta); + } + return queriedPatientEvents; + } + + private ClinicalData buildClinicalSurvivalMonths(String attributeIdPrefix, ClinicalEvent event, SurvivalRequest survivalRequest, List patientEndEvents, List patientCensoredEvents) { + final String SURVIVAL_MONTH_ATTRIBUTE = attributeIdPrefix + "_MONTHS"; + ClinicalData clinicalDataMonths = new ClinicalData(); + clinicalDataMonths.setStudyId(event.getStudyId()); + clinicalDataMonths.setPatientId(event.getPatientId()); + clinicalDataMonths.setAttrId(SURVIVAL_MONTH_ATTRIBUTE); + + Map patientEndEventsById = patientEndEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); + Map patientCensoredEventsById = patientCensoredEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); + + ToIntFunction startPositionIdentifier = getPositionIdentifier(survivalRequest.getStartEventRequestIdentifier().getPosition()); + ToIntFunction endPositionIdentifier = survivalRequest.getEndEventRequestIdentifier() == null ? ClinicalEvent::getStopDate : getPositionIdentifier(survivalRequest.getEndEventRequestIdentifier().getPosition()); + ToIntFunction censoredPositionIdentifier = survivalRequest.getCensoredEventRequestIdentifier() == null ? ClinicalEvent::getStopDate : getPositionIdentifier(survivalRequest.getCensoredEventRequestIdentifier().getPosition()); + + int startDate = startPositionIdentifier.applyAsInt(event); + int endDate; + if (patientEndEventsById.containsKey(getKey(event))) { + endDate = endPositionIdentifier.applyAsInt(patientEndEventsById.get(getKey(event))); + } else { + // ignore cases where patient does not have censored timeline events or + // stop date of start event is less than start date of censored events + if (!patientCensoredEventsById.containsKey(getKey(event)) || + startDate >= censoredPositionIdentifier.applyAsInt(patientCensoredEventsById.get(getKey(event))) + ) { + return null; + } + + endDate = censoredPositionIdentifier.applyAsInt(patientCensoredEventsById.get(getKey(event))); + } + final String SURVIVAL_MONTH = String.valueOf((endDate - startDate) / 30.4); + clinicalDataMonths.setAttrValue(SURVIVAL_MONTH); + + return clinicalDataMonths; + } + + private ClinicalData buildClinicalSurvivalStatus(String attributeIdPrefix, ClinicalEvent event, List patientEndEvents) { + Map patientEndEventsById = patientEndEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity())); + + ClinicalData clinicalDataStatus = new ClinicalData(); + clinicalDataStatus.setStudyId(event.getStudyId()); + clinicalDataStatus.setPatientId(event.getPatientId()); + clinicalDataStatus.setAttrId(attributeIdPrefix + "_STATUS"); + + if (patientEndEventsById.containsKey(getKey(event))) { + clinicalDataStatus.setAttrValue("1:EVENT"); + } else { + clinicalDataStatus.setAttrValue("0:CENSORED"); + } + + return clinicalDataStatus; + } } diff --git a/src/main/java/org/cbioportal/web/SurvivalController.java b/src/main/java/org/cbioportal/web/SurvivalController.java index 8032c6db697..202b344406c 100644 --- a/src/main/java/org/cbioportal/web/SurvivalController.java +++ b/src/main/java/org/cbioportal/web/SurvivalController.java @@ -9,12 +9,8 @@ import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.validation.Valid; import org.cbioportal.model.ClinicalData; -import org.cbioportal.model.ClinicalEvent; -import org.cbioportal.model.SurvivalEvent; import org.cbioportal.service.ClinicalEventService; import org.cbioportal.web.config.annotation.InternalApi; -import org.cbioportal.web.parameter.ClinicalEventRequestIdentifier; -import org.cbioportal.web.parameter.OccurrencePosition; import org.cbioportal.web.parameter.PatientIdentifier; import org.cbioportal.web.parameter.SurvivalRequest; import org.springframework.beans.factory.annotation.Autowired; @@ -32,7 +28,6 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; -import java.util.function.ToIntFunction; @InternalApi @RestController() @@ -71,47 +66,11 @@ public ResponseEntity> fetchSurvivalData( patientIds.add(patientIdentifier.getPatientId()); } - List endClinicalEventsMeta = new ArrayList<>(); - ToIntFunction endPositionIdentifier = ClinicalEvent::getStopDate; - if (interceptedSurvivalRequest.getEndEventRequestIdentifier() != null) { - endClinicalEventsMeta = getToClinicalEvents(interceptedSurvivalRequest.getEndEventRequestIdentifier()); - endPositionIdentifier = getPositionIdentifier(interceptedSurvivalRequest.getEndEventRequestIdentifier().getPosition()); - } - - List censoredClinicalEventsMeta = new ArrayList<>(); - ToIntFunction censoredPositionIdentifier = ClinicalEvent::getStopDate; - if (interceptedSurvivalRequest.getCensoredEventRequestIdentifier() != null) { - censoredClinicalEventsMeta = getToClinicalEvents(interceptedSurvivalRequest.getCensoredEventRequestIdentifier()); - censoredPositionIdentifier = getPositionIdentifier(interceptedSurvivalRequest.getCensoredEventRequestIdentifier().getPosition()); - } - - SurvivalEvent survivalEvent = new SurvivalEvent(); - survivalEvent.setStartClinicalEventsMeta(getToClinicalEvents(interceptedSurvivalRequest.getStartEventRequestIdentifier())); - survivalEvent.setStartPositionIdentifier(getPositionIdentifier(interceptedSurvivalRequest.getStartEventRequestIdentifier().getPosition())); - survivalEvent.setEndClinicalEventsMeta(endClinicalEventsMeta); - survivalEvent.setEndPositionIdentifier(endPositionIdentifier); - survivalEvent.setCensoredClinicalEventsMeta(censoredClinicalEventsMeta); - survivalEvent.setCensoredPositionIdentifier(censoredPositionIdentifier); - List result = clinicalEventService.getSurvivalData(studyIds, patientIds, interceptedSurvivalRequest.getAttributeIdPrefix(), - survivalEvent); + interceptedSurvivalRequest); return new ResponseEntity<>(result, HttpStatus.OK); } - - private static List getToClinicalEvents(ClinicalEventRequestIdentifier clinicalEventRequestIdentifier) { - return clinicalEventRequestIdentifier.getClinicalEventRequests().stream().map(x -> { - ClinicalEvent clinicalEvent = new ClinicalEvent(); - clinicalEvent.setEventType(x.getEventType()); - clinicalEvent.setAttributes(x.getAttributes()); - - return clinicalEvent; - }).toList(); - } - - private ToIntFunction getPositionIdentifier(OccurrencePosition position) { - return position.equals(OccurrencePosition.FIRST) ? ClinicalEvent::getStartDate : ClinicalEvent::getStopDate; - } } diff --git a/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java b/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java index 9b19435f82e..b246c3863e6 100644 --- a/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java +++ b/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java @@ -5,11 +5,14 @@ import org.cbioportal.model.ClinicalEventData; import org.cbioportal.model.ClinicalEventTypeCount; import org.cbioportal.model.Patient; -import org.cbioportal.model.SurvivalEvent; import org.cbioportal.model.meta.BaseMeta; import org.cbioportal.persistence.ClinicalEventRepository; import org.cbioportal.service.PatientService; import org.cbioportal.service.exception.PatientNotFoundException; +import org.cbioportal.web.parameter.ClinicalEventRequest; +import org.cbioportal.web.parameter.ClinicalEventRequestIdentifier; +import org.cbioportal.web.parameter.OccurrencePosition; +import org.cbioportal.web.parameter.SurvivalRequest; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; @@ -32,7 +35,9 @@ @RunWith(MockitoJUnitRunner.class) public class ClinicalEventServiceImplTest extends BaseServiceImplTest { - private static final String TEST_CLINICAL_EVENT_TYPE = "SERVICE"; + private static final String TEST_CLINICAL_EVENT_TYPE_1 = "SERVICE"; + private static final String TEST_CLINICAL_EVENT_TYPE_2 = "test_clinical_event_type_2"; + private static final String TEST_CLINICAL_EVENT_TYPE_3 = "test_clinical_event_type_3"; private static final String TEST_SURVIVAL_PREFIX = "survival_prefix"; @InjectMocks @@ -144,7 +149,7 @@ public void getPatientsSamplesPerClinicalEventType() { List sampleIds = Arrays.asList(SAMPLE_ID1); Map> patientsSamplesPerEventType = new HashMap<>(); - patientsSamplesPerEventType.put(TEST_CLINICAL_EVENT_TYPE, new HashSet<>(sampleIds)); + patientsSamplesPerEventType.put(TEST_CLINICAL_EVENT_TYPE_1, new HashSet<>(sampleIds)); when(clinicalEventRepository.getSamplesOfPatientsPerEventTypeInStudy(anyList(), anyList())) .thenReturn(patientsSamplesPerEventType); @@ -163,7 +168,7 @@ public void getClinicalEventTypeCounts() { p.setStableId(PATIENT_ID_1); ClinicalEvent ce = new ClinicalEvent(); - ce.setEventType(TEST_CLINICAL_EVENT_TYPE); + ce.setEventType(TEST_CLINICAL_EVENT_TYPE_1); when(patientService.getPatientsOfSamples(anyList(), anyList())) .thenReturn(Arrays.asList(p)); @@ -204,6 +209,14 @@ public void getSurvivalDataReturnsCorrectDataWhenEndEventsExist() throws Excepti startClinicalEvents.add(clinicalEvent2); startClinicalEvents.add(clinicalEvent3); + List startEventMetas = new ArrayList<>(); + ClinicalEvent startEventMeta = new ClinicalEvent(); + startEventMeta.setEventType(TEST_CLINICAL_EVENT_TYPE_1); + startEventMetas.add(startEventMeta); + + when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), eq(startEventMetas))) + .thenReturn(startClinicalEvents); + List endClinicalEvents = new ArrayList<>(); ClinicalEvent clinicalEvent4 = new ClinicalEvent(); clinicalEvent4.setStudyId(STUDY_ID); @@ -212,6 +225,14 @@ public void getSurvivalDataReturnsCorrectDataWhenEndEventsExist() throws Excepti clinicalEvent4.setStopDate(1000); endClinicalEvents.add(clinicalEvent4); + + List endEventMetas = new ArrayList<>(); + ClinicalEvent endEventMeta = new ClinicalEvent(); + endEventMeta.setEventType(TEST_CLINICAL_EVENT_TYPE_2); + endEventMetas.add(endEventMeta); + + when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), eq(endEventMetas))) + .thenReturn(endClinicalEvents); List censoredClinicalEvents = new ArrayList<>(); ClinicalEvent clinicalEvent5 = new ClinicalEvent(); @@ -229,22 +250,44 @@ public void getSurvivalDataReturnsCorrectDataWhenEndEventsExist() throws Excepti censoredClinicalEvents.add(clinicalEvent5); censoredClinicalEvents.add(clinicalEvent6); - SurvivalEvent survivalEvent = new SurvivalEvent(); - survivalEvent.setStartClinicalEventsMeta(startClinicalEvents); - survivalEvent.setStartPositionIdentifier(ClinicalEvent::getStartDate); - survivalEvent.setEndClinicalEventsMeta(endClinicalEvents); - survivalEvent.setEndPositionIdentifier(ClinicalEvent::getStopDate); - survivalEvent.setCensoredClinicalEventsMeta(censoredClinicalEvents); - survivalEvent.setCensoredPositionIdentifier(ClinicalEvent::getStopDate); - - when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), eq(startClinicalEvents))) - .thenReturn(startClinicalEvents); - when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), eq(endClinicalEvents))) - .thenReturn(endClinicalEvents); - when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), eq(censoredClinicalEvents))) + List censoredEventMetas = new ArrayList<>(); + ClinicalEvent censoredEventMeta = new ClinicalEvent(); + censoredEventMeta.setEventType(TEST_CLINICAL_EVENT_TYPE_3); + censoredEventMetas.add(censoredEventMeta); + + when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), eq(censoredEventMetas))) .thenReturn(censoredClinicalEvents); - List result = clinicalEventService.getSurvivalData(studyIds, patientIds, TEST_SURVIVAL_PREFIX, survivalEvent); + SurvivalRequest survivalRequest = new SurvivalRequest(); + + ClinicalEventRequestIdentifier startEventRequestIdentifier = new ClinicalEventRequestIdentifier(); + Set startClinicalEventRequests = new HashSet<>(); + ClinicalEventRequest clinicalEventRequest1 = new ClinicalEventRequest(); + clinicalEventRequest1.setEventType(TEST_CLINICAL_EVENT_TYPE_1); + startClinicalEventRequests.add(clinicalEventRequest1); + startEventRequestIdentifier.setClinicalEventRequests(startClinicalEventRequests); + startEventRequestIdentifier.setPosition(OccurrencePosition.FIRST); + survivalRequest.setStartEventRequestIdentifier(startEventRequestIdentifier); + + ClinicalEventRequestIdentifier endEventRequestIdentifier = new ClinicalEventRequestIdentifier(); + Set endClinicalEventRequests = new HashSet<>(); + ClinicalEventRequest clinicalEventRequest2 = new ClinicalEventRequest(); + clinicalEventRequest2.setEventType(TEST_CLINICAL_EVENT_TYPE_2); + endClinicalEventRequests.add(clinicalEventRequest2); + endEventRequestIdentifier.setClinicalEventRequests(endClinicalEventRequests); + endEventRequestIdentifier.setPosition(OccurrencePosition.LAST); + survivalRequest.setEndEventRequestIdentifier(endEventRequestIdentifier); + + ClinicalEventRequestIdentifier censoredEventRequestIdentifier = new ClinicalEventRequestIdentifier(); + Set censoredClinicalEventRequests = new HashSet<>(); + ClinicalEventRequest clinicalEventRequest3 = new ClinicalEventRequest(); + clinicalEventRequest3.setEventType(TEST_CLINICAL_EVENT_TYPE_3); + censoredClinicalEventRequests.add(clinicalEventRequest3); + censoredEventRequestIdentifier.setClinicalEventRequests(censoredClinicalEventRequests); + censoredEventRequestIdentifier.setPosition(OccurrencePosition.LAST); + survivalRequest.setCensoredEventRequestIdentifier(censoredEventRequestIdentifier); + + List result = clinicalEventService.getSurvivalData(studyIds, patientIds, TEST_SURVIVAL_PREFIX, survivalRequest); assertEquals(4, result.size()); assertEquals(PATIENT_ID_1, result.getFirst().getPatientId()); @@ -280,18 +323,39 @@ public void getSurvivalDataReturnsEmptyListWhenNoEventsExist() throws Exception clinicalEventList.add(clinicalEvent1); clinicalEventList.add(clinicalEvent2); - SurvivalEvent survivalEvent = new SurvivalEvent(); - survivalEvent.setStartClinicalEventsMeta(clinicalEventList); - survivalEvent.setStartPositionIdentifier(ClinicalEvent::getStartDate); - survivalEvent.setEndClinicalEventsMeta(clinicalEventList); - survivalEvent.setEndPositionIdentifier(ClinicalEvent::getStopDate); - survivalEvent.setCensoredClinicalEventsMeta(clinicalEventList); - survivalEvent.setCensoredPositionIdentifier(ClinicalEvent::getStopDate); + SurvivalRequest survivalRequest = new SurvivalRequest(); + + ClinicalEventRequestIdentifier startEventRequestIdentifier = new ClinicalEventRequestIdentifier(); + Set startClinicalEventRequests = new HashSet<>(); + ClinicalEventRequest clinicalEventRequest1 = new ClinicalEventRequest(); + clinicalEventRequest1.setEventType(TEST_CLINICAL_EVENT_TYPE_1); + startClinicalEventRequests.add(clinicalEventRequest1); + startEventRequestIdentifier.setClinicalEventRequests(startClinicalEventRequests); + startEventRequestIdentifier.setPosition(OccurrencePosition.FIRST); + survivalRequest.setStartEventRequestIdentifier(startEventRequestIdentifier); + + ClinicalEventRequestIdentifier endEventRequestIdentifier = new ClinicalEventRequestIdentifier(); + Set endClinicalEventRequests = new HashSet<>(); + ClinicalEventRequest clinicalEventRequest2 = new ClinicalEventRequest(); + clinicalEventRequest2.setEventType(TEST_CLINICAL_EVENT_TYPE_2); + endClinicalEventRequests.add(clinicalEventRequest2); + endEventRequestIdentifier.setClinicalEventRequests(endClinicalEventRequests); + endEventRequestIdentifier.setPosition(OccurrencePosition.LAST); + survivalRequest.setEndEventRequestIdentifier(endEventRequestIdentifier); + + ClinicalEventRequestIdentifier censoredEventRequestIdentifier = new ClinicalEventRequestIdentifier(); + Set censoredClinicalEventRequests = new HashSet<>(); + ClinicalEventRequest clinicalEventRequest3 = new ClinicalEventRequest(); + clinicalEventRequest3.setEventType(TEST_CLINICAL_EVENT_TYPE_3); + censoredClinicalEventRequests.add(clinicalEventRequest3); + censoredEventRequestIdentifier.setClinicalEventRequests(censoredClinicalEventRequests); + censoredEventRequestIdentifier.setPosition(OccurrencePosition.LAST); + survivalRequest.setCensoredEventRequestIdentifier(censoredEventRequestIdentifier); when(clinicalEventRepository.getTimelineEvents(anyList(), anyList(), anyList())) .thenReturn(new ArrayList<>()); - List result = clinicalEventService.getSurvivalData(studyIds, patientIds, TEST_SURVIVAL_PREFIX, survivalEvent); + List result = clinicalEventService.getSurvivalData(studyIds, patientIds, TEST_SURVIVAL_PREFIX, survivalRequest); assertTrue(result.isEmpty()); } From 1b16b89b9269d5e8940080dbb42354e8c1aa62a0 Mon Sep 17 00:00:00 2001 From: Qi-Xuan Lu Date: Mon, 10 Jun 2024 12:41:26 -0400 Subject: [PATCH 12/12] addressed sonarcloud issues and cleanup --- .../service/impl/ClinicalEventServiceImpl.java | 4 ++-- .../mybatis/ClinicalEventMyBatisRepositoryTest.java | 2 +- .../service/impl/ClinicalDataServiceImplTest.java | 0 .../service/impl/ClinicalEventServiceImplTest.java | 10 +++++----- src/test/resources/logback.xml | 3 --- 5 files changed, 8 insertions(+), 11 deletions(-) mode change 100644 => 100755 src/test/java/org/cbioportal/service/impl/ClinicalDataServiceImplTest.java diff --git a/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java b/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java index 6a00c9c060d..6d70c1647f6 100644 --- a/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java +++ b/src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java @@ -147,7 +147,7 @@ public List getSurvivalData(List studyIds, .map(endPositionIdentifier::applyAsInt) .map(endDate -> startPositionIdentifier.applyAsInt(event) < endDate) .orElse(true) - ).collect(Collectors.toList()); + ).toList(); List patientCensoredEvents = filterClinicalEvents(patientStartEvents, survivalRequest.getCensoredEventRequestIdentifier()); @@ -177,7 +177,7 @@ private static List getToClinicalEvents(ClinicalEventRequestIdent clinicalEvent.setAttributes(x.getAttributes()); return clinicalEvent; - }).collect(Collectors.toList()); + }).toList(); } private ToIntFunction getPositionIdentifier(OccurrencePosition position) { diff --git a/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java b/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java index 18d6745801d..60a8d1067de 100644 --- a/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java +++ b/src/test/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepositoryTest.java @@ -290,7 +290,7 @@ public void getClinicalEventsMeta() { requestClinicalEvent.setAttributes(Arrays.asList(clinicalEventData1, clinicalEventData2)); List result = clinicalEventMyBatisRepository.getClinicalEventsMeta(studyList, patientList, List.of(requestClinicalEvent)); - List eventTypes = result.stream().map(ClinicalEvent::getEventType).collect(Collectors.toList()); + List eventTypes = result.stream().map(ClinicalEvent::getEventType).toList(); Assert.assertEquals(1, result.size()); Assert.assertTrue(eventTypes.contains("treatment")); } diff --git a/src/test/java/org/cbioportal/service/impl/ClinicalDataServiceImplTest.java b/src/test/java/org/cbioportal/service/impl/ClinicalDataServiceImplTest.java old mode 100644 new mode 100755 diff --git a/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java b/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java index b246c3863e6..e6fe83f8c7e 100644 --- a/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java +++ b/src/test/java/org/cbioportal/service/impl/ClinicalEventServiceImplTest.java @@ -105,7 +105,7 @@ public void getMetaPatientClinicalEventsPatientNotFound() throws Exception { } @Test - public void getAllClinicalEventsInStudy() throws Exception { + public void getAllClinicalEventsInStudy() { List expectedClinicalEventList = new ArrayList<>(); ClinicalEvent clinicalEvent = new ClinicalEvent(); @@ -182,7 +182,7 @@ public void getClinicalEventTypeCounts() { } @Test - public void getSurvivalDataReturnsCorrectDataWhenEndEventsExist() throws Exception { + public void getSurvivalDataReturnsCorrectDataWhenEndEventsExist() { List studyIds = List.of(STUDY_ID); List patientIds = Arrays.asList(PATIENT_ID_1, PATIENT_ID_2, PATIENT_ID_3); @@ -303,7 +303,7 @@ public void getSurvivalDataReturnsCorrectDataWhenEndEventsExist() throws Excepti } @Test - public void getSurvivalDataReturnsEmptyListWhenNoEventsExist() throws Exception { + public void getSurvivalDataReturnsEmptyListWhenNoEventsExist() { List studyIds = List.of(STUDY_ID); List patientIds = Arrays.asList(PATIENT_ID_1, PATIENT_ID_2, PATIENT_ID_3); @@ -361,7 +361,7 @@ public void getSurvivalDataReturnsEmptyListWhenNoEventsExist() throws Exception } @Test - public void getClinicalEventsMetaReturnsCorrectDataForValidInput() throws Exception { + public void getClinicalEventsMetaReturnsCorrectDataForValidInput() { List studyIds = List.of(STUDY_ID); List patientIds = Arrays.asList(PATIENT_ID_1, PATIENT_ID_2); List clinicalEvents = new ArrayList<>(); @@ -386,7 +386,7 @@ public void getClinicalEventsMetaReturnsCorrectDataForValidInput() throws Except } @Test - public void getClinicalEventsMetaReturnsEmptyListForInvalidInput() throws Exception { + public void getClinicalEventsMetaReturnsEmptyListForInvalidInput() { List studyIds = List.of(STUDY_ID); List patientIds = Arrays.asList(PATIENT_ID_1, PATIENT_ID_2); List clinicalEvents = new ArrayList<>(); diff --git a/src/test/resources/logback.xml b/src/test/resources/logback.xml index b9e08aba003..9d21a927c45 100644 --- a/src/test/resources/logback.xml +++ b/src/test/resources/logback.xml @@ -16,9 +16,6 @@ --> - - -