New Survival Data Endpoint for Dynamic Kaplan-Meier Curve

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();

src/main/java/org/cbioportal/model/ClinicalEvent.java

@@ -1,8 +1,10 @@
 package org.cbioportal.model;
 
-import java.util.List;
 import jakarta.validation.constraints.NotNull;
 
+import java.util.List;
+import java.util.Objects;
+
 public class ClinicalEvent extends UniqueKeyBase {
 
     private Integer clinicalEventId;
@@ -71,4 +73,17 @@ public List<ClinicalEventData> getAttributes() {
     public void setAttributes(List<ClinicalEventData> 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);
+    }
 }

src/main/java/org/cbioportal/persistence/ClinicalEventRepository.java

@@ -35,4 +35,11 @@ List<ClinicalEvent> getAllClinicalEventsInStudy(String studyId, String projectio
 
     @Cacheable(cacheResolver = "generalRepositoryCacheResolver", condition = "@cacheEnabledConfig.getEnabled()")
     List<ClinicalEvent> getPatientsDistinctClinicalEventInStudies(List<String> studyIds, List<String> patientIds);
+
+
+    @Cacheable(cacheResolver = "generalRepositoryCacheResolver", condition = "@cacheEnabledConfig.getEnabled()")
+    List<ClinicalEvent> getTimelineEvents(List<String> studyIds, List<String> patientIds, List<ClinicalEvent> clinicalEvents);
+
+    @Cacheable(cacheResolver = "generalRepositoryCacheResolver", condition = "@cacheEnabledConfig.getEnabled()")
+    List<ClinicalEvent> getClinicalEventsMeta(List<String> studyIds, List<String> patientIds, List<ClinicalEvent> clinicalEvents);
 }

src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMapper.java

@@ -23,4 +23,8 @@ List<ClinicalEvent> getStudyClinicalEvent(String studyId, String projection, Int
     List<ClinicalEvent> getSamplesOfPatientsPerEventType(List<String> studyIds, List<String> sampleIds);
 
     List<ClinicalEvent> getPatientsDistinctClinicalEventInStudies(List<String> studyIds, List<String> patientIds);
+
+    List<ClinicalEvent> getTimelineEvents(List<String> studyIds, List<String> patientIds, List<ClinicalEvent> clinicalEvents);
+
+    List<ClinicalEvent> getClinicalEventsMeta(List<String> studyIds, List<String> patientIds, List<ClinicalEvent> clinicalEvents);
 }

src/main/java/org/cbioportal/persistence/mybatis/ClinicalEventMyBatisRepository.java

@@ -66,4 +66,16 @@ public Map<String, Set<String>> getSamplesOfPatientsPerEventTypeInStudy(List<Str
     public List<ClinicalEvent> getPatientsDistinctClinicalEventInStudies(List<String> studyIds, List<String> patientIds) {
         return clinicalEventMapper.getPatientsDistinctClinicalEventInStudies(studyIds, patientIds);
     }
+
+    @Override
+    public List<ClinicalEvent> getTimelineEvents(List<String> studyIds,
+                                                 List<String> patientIds,
+                                                 List<ClinicalEvent> clinicalEvents) {
+        return clinicalEventMapper.getTimelineEvents(studyIds, patientIds, clinicalEvents);
+    }
+
+    @Override
+    public List<ClinicalEvent> getClinicalEventsMeta(List<String> studyIds, List<String> patientIds, List<ClinicalEvent> clinicalEvents) {
+        return clinicalEventMapper.getClinicalEventsMeta(studyIds, patientIds, clinicalEvents);
+    }
 }

src/main/java/org/cbioportal/service/ClinicalEventService.java

@@ -1,10 +1,12 @@
 package org.cbioportal.service;
 
+import org.cbioportal.model.ClinicalData;
 import org.cbioportal.model.ClinicalEvent;
 import org.cbioportal.model.ClinicalEventTypeCount;
 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;
@@ -29,4 +31,11 @@ BaseMeta getMetaClinicalEvents(String studyId)
     Map<String, Set<String>> getPatientsSamplesPerClinicalEventType(List<String> studyIds, List<String> sampleIds); 
 
     List<ClinicalEventTypeCount> getClinicalEventTypeCounts(List<String> studyIds, List<String> sampleIds);
+
+    List<ClinicalData> getSurvivalData(List<String> studyIds, List<String> patientIds,
+                                       String attributeIdPrefix,
+                                       SurvivalRequest survivalRequest);
+
+    List<ClinicalEvent> getClinicalEventsMeta(List<String> studyIds, List<String> patientIds,
+                                       List<ClinicalEvent> clinicalEvents);
 }

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),

src/main/java/org/cbioportal/service/impl/ClinicalEventServiceImpl.java

@@ -1,17 +1,33 @@
 package org.cbioportal.service.impl;
 
-import org.cbioportal.model.*;
+import org.apache.commons.collections4.CollectionUtils;
+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.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;
 
-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;
 
 @Service
 public class ClinicalEventServiceImpl implements ClinicalEventService {
@@ -108,4 +124,137 @@ public List<ClinicalEventTypeCount> getClinicalEventTypeCounts(List<String> stud
             .map(e -> new ClinicalEventTypeCount(e.getKey(),e.getValue()))
             .collect(Collectors.toList());
     }
+
+    @Override
+    public List<ClinicalData> getSurvivalData(List<String> studyIds,
+                                              List<String> patientIds,
+                                              String attributeIdPrefix,
+                                              SurvivalRequest survivalRequest) {
+        List<ClinicalEvent> startClinicalEventsMeta = getToClinicalEvents(survivalRequest.getStartEventRequestIdentifier());
+        List<ClinicalEvent> patientStartEvents = clinicalEventRepository.getTimelineEvents(studyIds, patientIds, startClinicalEventsMeta);
+
+        // only fetch end timeline events for patients that have endClinicalEventsMeta and start timeline events
+        List<ClinicalEvent> patientEndEvents = filterClinicalEvents(patientStartEvents, survivalRequest.getEndEventRequestIdentifier());
+
+        ToIntFunction<ClinicalEvent> startPositionIdentifier = getPositionIdentifier(survivalRequest.getStartEventRequestIdentifier().getPosition());
+        ToIntFunction<ClinicalEvent> endPositionIdentifier = getPositionIdentifier(survivalRequest.getEndEventRequestIdentifier().getPosition());
+        Map<String, ClinicalEvent> 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(event ->
+                Optional.ofNullable(patientEndEventsById.get(getKey(event)))
+                    .map(endPositionIdentifier::applyAsInt)
+                    .map(endDate -> startPositionIdentifier.applyAsInt(event) < endDate)
+                    .orElse(true)
+            ).toList();
+
+        List<ClinicalEvent> patientCensoredEvents = filterClinicalEvents(patientStartEvents, survivalRequest.getCensoredEventRequestIdentifier());
+
+        return patientStartEvents.stream()
+            .flatMap(event -> {
+                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();
+    }
+
+    @Override
+    public List<ClinicalEvent> getClinicalEventsMeta(List<String> studyIds, List<String> patientIds, List<ClinicalEvent> clinicalEvents) {
+        return clinicalEventRepository.getClinicalEventsMeta(studyIds, patientIds, clinicalEvents);
+    }
+
+    private static String getKey(ClinicalEvent clinicalEvent) {
+        return clinicalEvent.getStudyId() + clinicalEvent.getPatientId();
+    }
+
+    private static List<ClinicalEvent> 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<ClinicalEvent> getPositionIdentifier(OccurrencePosition position) {
+        return position.equals(OccurrencePosition.FIRST) ? ClinicalEvent::getStartDate : ClinicalEvent::getStopDate;
+    }
+
+    private List<ClinicalEvent> filterClinicalEvents(List<ClinicalEvent> patientEvents,
+                                                     ClinicalEventRequestIdentifier clinicalEventRequestIdentifier) {
+        List<String> filteredStudyIds = new ArrayList<>();
+        List<String> filteredPatientIds = new ArrayList<>();
+        for (ClinicalEvent clinicalEvent : patientEvents) {
+            filteredStudyIds.add(clinicalEvent.getStudyId());
+            filteredPatientIds.add(clinicalEvent.getPatientId());
+        }
+
+        List<ClinicalEvent> clinicalEventsMeta = new ArrayList<>();
+        if (clinicalEventRequestIdentifier != null) {
+            clinicalEventsMeta = getToClinicalEvents(clinicalEventRequestIdentifier);
+        }
+
+        // only fetch end timeline events for patients that have endClinicalEventsMeta and start timeline events
+        List<ClinicalEvent> 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<ClinicalEvent> patientEndEvents, List<ClinicalEvent> 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<String, ClinicalEvent> patientEndEventsById = patientEndEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity()));
+        Map<String, ClinicalEvent> patientCensoredEventsById = patientCensoredEvents.stream().collect(Collectors.toMap(ClinicalEventServiceImpl::getKey, Function.identity()));
+
+        ToIntFunction<ClinicalEvent> startPositionIdentifier = getPositionIdentifier(survivalRequest.getStartEventRequestIdentifier().getPosition());
+        ToIntFunction<ClinicalEvent> endPositionIdentifier = survivalRequest.getEndEventRequestIdentifier() == null ? ClinicalEvent::getStopDate : getPositionIdentifier(survivalRequest.getEndEventRequestIdentifier().getPosition());
+        ToIntFunction<ClinicalEvent> 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<ClinicalEvent> patientEndEvents) {
+        Map<String, ClinicalEvent> 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;
+    }
 }

src/main/java/org/cbioportal/web/ClinicalEventController.java

@@ -7,6 +7,7 @@
 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 jakarta.validation.constraints.Max;
 import jakarta.validation.constraints.Min;
 import org.cbioportal.model.ClinicalEvent;
@@ -15,9 +16,11 @@
 import org.cbioportal.service.exception.StudyNotFoundException;
 import org.cbioportal.web.config.InternalApiTags;
 import org.cbioportal.web.config.annotation.InternalApi;
+import org.cbioportal.web.parameter.ClinicalEventAttributeRequest;
 import org.cbioportal.web.parameter.Direction;
 import org.cbioportal.web.parameter.HeaderKeyConstants;
 import org.cbioportal.web.parameter.PagingConstants;
+import org.cbioportal.web.parameter.PatientIdentifier;
 import org.cbioportal.web.parameter.Projection;
 import org.cbioportal.web.parameter.sort.ClinicalEventSortBy;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -28,11 +31,15 @@
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestAttribute;
+import org.springframework.web.bind.annotation.RequestBody;
 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 java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 @InternalApi
@@ -120,4 +127,42 @@ public ResponseEntity<List<ClinicalEvent>> getAllClinicalEventsInStudy(
                     sortBy == null ? null : sortBy.getOriginalValue(), direction.name()), HttpStatus.OK);
         }
     }
+
+    @PreAuthorize("hasPermission(#involvedCancerStudies, 'Collection<CancerStudyId>', 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)
+    @Operation(description = "Fetch clinical events meta")
+    @ApiResponse(responseCode = "200", description = "OK",
+        content = @Content(array = @ArraySchema(schema = @Schema(implementation = ClinicalEvent.class))))
+    public ResponseEntity<List<ClinicalEvent>> fetchClinicalEventsMeta(
+        @Parameter(required = true, description = "clinical events Request")
+        @Valid @RequestBody(required = false) ClinicalEventAttributeRequest clinicalEventAttributeRequest,
+        @Parameter(hidden = true) // prevent reference to this attribute in the swagger-ui interface
+        @RequestAttribute(required = false, value = "involvedCancerStudies") Collection<String> involvedCancerStudies,
+        @Parameter(hidden = true) // 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<String> studyIds = new ArrayList<>();
+        List<String> patientIds = new ArrayList<>();
+        for (PatientIdentifier patientIdentifier : interceptedClinicalEventAttributeRequest.getPatientIdentifiers()) {
+            studyIds.add(patientIdentifier.getStudyId());
+            patientIds.add(patientIdentifier.getPatientId());
+        }
+
+        List<ClinicalEvent> clinicalEventsRequest = interceptedClinicalEventAttributeRequest.getClinicalEventRequests()
+            .stream()
+            .map(x -> {
+                ClinicalEvent clinicalEvent = new ClinicalEvent();
+                clinicalEvent.setEventType(x.getEventType());
+                clinicalEvent.setAttributes(x.getAttributes());
+                return clinicalEvent;
+            })
+            .toList();
+
+        return new ResponseEntity<>(clinicalEventService.getClinicalEventsMeta(
+            studyIds, patientIds, clinicalEventsRequest), HttpStatus.OK);
+
+    }
 }