Gene-specific chart finalized

Author: i-am-leslie

src/pages/studyView/StudyViewPageStore.ts

@@ -186,6 +186,8 @@ import {
     transformSampleDataToSelectedSampleClinicalData,
     updateCustomIntervalFilter,
     invokeGenomicDataCount,
+    invokeGenomicDataCountIncludeSampleid,
+    groupSamplesByMutationStatus,
     invokeMutationDataCount,
     invokeNamespaceDataCount,
     invokeGenericAssayDataCount,
@@ -1635,6 +1637,79 @@ export class StudyViewPageStore
         });
     }
 
+    private createGeneSpecificComparisonSession(
+        chartMeta: ChartMeta,
+        clinicalAttributeValues: ClinicalDataCountSummary[],
+        statusCallback: (phase: LoadingPhase) => void
+    ): Promise<string> {
+        statusCallback(LoadingPhase.DOWNLOADING_GROUPS);
+
+        return new Promise<string>(resolve => {
+            onMobxPromise([this.selectedSamples], async () => {
+                const chartInfo = this._geneSpecificChartMap.get(
+                    chartMeta.uniqueKey
+                );
+                if (!chartInfo || !this.hasFilteredSamples) return;
+
+                const data: any[] = await invokeGenomicDataCountIncludeSampleid(
+                    chartInfo,
+                    this.filters,
+                    true
+                );
+
+                const lcValueToColor = _.keyBy(clinicalAttributeValues, d =>
+                    d.value.toLowerCase()
+                );
+
+                /**
+                 * Step 1:
+                 * Normalize counts into { group, sampleId } pairs
+                 */
+                const groupedSamples = groupSamplesByMutationStatus(data);
+
+                /**
+                 * Step 2:
+                 * Build SessionGroupData objects for each group, using the sample ids from step 1
+                 */
+                const groups: SessionGroupData[] = _.chain(
+                    clinicalAttributeValues
+                )
+                    .map(attrVal => {
+                        const sampleIds = groupedSamples[attrVal.value];
+                        if (!sampleIds?.length) return null;
+
+                        return getGroupParameters(
+                            attrVal.value,
+                            sampleIds.map(id => ({
+                                sampleId: id,
+                                studyId: this.studyIds[0],
+                            })),
+                            this.studyIds,
+                            lcValueToColor[attrVal.value.toLowerCase()]?.color
+                        );
+                    })
+                    .compact()
+                    .slice(
+                        0,
+                        doesChartHaveComparisonGroupsLimit(chartMeta)
+                            ? MAX_GROUPS_IN_SESSION
+                            : undefined
+                    )
+                    .value();
+
+                statusCallback(LoadingPhase.CREATING_SESSION);
+
+                const { id } = await comparisonClient.addComparisonSession({
+                    groups,
+                    clinicalAttributeName: chartMeta.displayName,
+                    origin: this.studyIds,
+                });
+
+                resolve(id);
+            });
+        });
+    }
+
     private createCnaGeneComparisonSession(
         chartMeta: ChartMeta,
         hugoGeneSymbols: string[],
@@ -2069,13 +2144,9 @@ export class StudyViewPageStore
                     chartMeta.uniqueKey
                 );
                 if (isGeneSpecificChart) {
-                    const chartInfo = this._geneSpecificChartMap.get(
-                        chartMeta.uniqueKey
-                    )!;
-
-                    comparisonId = await this.createCnaGeneComparisonSession(
+                    comparisonId = await this.createGeneSpecificComparisonSession(
                         chartMeta,
-                        [chartInfo.hugoGeneSymbol],
+                        params.clinicalAttributeValues!,
                         statusCallback
                     );
                 } else {

src/pages/studyView/StudyViewUtils.spec.tsx

@@ -66,6 +66,7 @@ import {
     updateCustomIntervalFilter,
     updateGeneQuery,
     updateSavedUserPreferenceChartIds,
+    groupSamplesByMutationStatus,
 } from 'pages/studyView/StudyViewUtils';
 import {
     CancerStudy,
@@ -3656,6 +3657,69 @@ describe('StudyViewUtils', () => {
         });
     });
 
+    describe('groupSamplesByMutationStatus', () => {
+        const data = [
+            {
+                counts: [
+                    {
+                        value: 'NOT_PROFILED',
+                        sampleIds: ['ignore_me_001'],
+                    },
+                ],
+            },
+            {
+                counts: [
+                    {
+                        value: 'Missense_Mutation',
+                        sampleIds: ['study_ABC_123', 'study_DEF_456'],
+                    },
+                ],
+            },
+            {
+                counts: [
+                    {
+                        value: 'NOT_MUTATED',
+                        sampleIds: ['study_GHI_789'],
+                    },
+                ],
+            },
+        ] as any;
+
+        it('groups and trims sample ids by mutation status correctly', () => {
+            const result = groupSamplesByMutationStatus(data);
+            assert.deepEqual(result, {
+                MUTATED: ['123', '456'],
+                NOT_MUTATED: ['789'],
+            });
+        });
+
+        it('handles missing or empty counts safely', () => {
+            const emptyData = [{}, { counts: [] }];
+            expect(groupSamplesByMutationStatus(emptyData)).toEqual({});
+        });
+
+        it('deduplicates sample IDs across mutation entries', () => {
+            const duplicateData = [
+                {
+                    counts: [
+                        {
+                            value: 'Missense_Mutation',
+                            sampleIds: ['study_X_001', 'study_X_002'],
+                        },
+                        {
+                            value: 'Nonsense_Mutation',
+                            sampleIds: ['study_X_001'],
+                        },
+                    ],
+                },
+            ];
+
+            expect(groupSamplesByMutationStatus(duplicateData)).toEqual({
+                MUTATED: ['001', '002'],
+            });
+        });
+    });
+
     describe('getFilteredStudiesWithSamples', () => {
         const samples: Sample[] = [
             {

src/pages/studyView/StudyViewUtils.tsx

@@ -125,6 +125,7 @@ import { MultiSelectionTableRow } from './table/MultiSelectionTable';
 import Survival from 'pages/groupComparison/Survival';
 import { StructVarMultiSelectionTableRow } from './table/StructuralVariantMultiSelectionTable';
 import { ObservableMap } from 'mobx';
+import { boolean } from 'yargs';
 
 // Cannot use ClinicalDataTypeEnum here for the strong type. The model in the type is not strongly typed
 export enum ClinicalDataTypeEnum {
@@ -4252,6 +4253,55 @@ export async function invokeGenericAssayDataCount(
     return undefined;
 }
 
+export async function invokeGenomicDataCountIncludeSampleid(
+    chartInfo: GenomicChart,
+    filters: StudyViewFilter,
+    includeSampleIds: boolean
+) {
+    let result = [];
+    let params = {
+        genomicDataCountFilter: {
+            genomicDataFilters: [
+                {
+                    hugoGeneSymbol: chartInfo.hugoGeneSymbol,
+                    profileType: chartInfo.profileType,
+                } as GenomicDataFilter,
+            ],
+            studyViewFilter: filters,
+        },
+        $queryParameters: {
+            projection: 'DETAILED',
+            includeSampleIds,
+        },
+    } as any;
+
+    result = await getInternalClient().fetchMutationDataCountsUsingPOST(params);
+
+    return result;
+}
+
+export function groupSamplesByMutationStatus(data: any[]) {
+    const SKIP_VALUES = new Set(['NOT_PROFILED']);
+    const NON_MUTATION_VALUES = new Set(['NOT_MUTATED']);
+
+    return _.chain(data)
+        .flatMap(d => d.counts ?? [])
+        .filter(c => !SKIP_VALUES.has(c.value) && c.sampleIds.length > 0)
+        .flatMap(c => {
+            const group = NON_MUTATION_VALUES.has(c.value)
+                ? c.value
+                : 'MUTATED';
+
+            return c.sampleIds.map((rawId: string) => ({
+                group,
+                sampleId: rawId.substring(rawId.lastIndexOf('_') + 1),
+            }));
+        })
+        .groupBy('group')
+        .mapValues(items => _.uniq(items.map(i => i.sampleId)))
+        .value();
+}
+
 export async function invokeGenomicDataCount(
     chartInfo: GenomicChart,
     filters: StudyViewFilter

src/pages/studyView/charts/ChartContainer.tsx

@@ -406,8 +406,7 @@ export class ChartContainer extends React.Component<IChartContainerProps, {}> {
             (this.props.promise.result.treatments ??
                 this.props.promise.result.patientTreatments ??
                 this.props.promise.result)!.length > 1 &&
-            COMPARISON_CHART_TYPES.indexOf(this.props.chartType) > -1 &&
-            !this.props.chartMeta.mutationOptionType
+            COMPARISON_CHART_TYPES.indexOf(this.props.chartType) > -1
         );
     }