feat(website, backend): Sequence citations

backend/src/main/kotlin/org/loculus/backend/api/SeqSetCitations.kt

@@ -97,6 +97,24 @@ data class SeqSetCitationSource(val source: CitationSource, val seqSetDOIs: Set<
 @Schema(description = "A citation of a SeqSet.")
 data class SeqSetCitation(val source: CitationSource)
 
+data class SeqSetCitingSequence(
+    @Schema(
+        description = "The accession and version of the SeqSet that was cited.",
+        type = "string",
+        example = "PP_SS_1.1",
+    )
+    val seqSetAccessionVersion: String,
+    @Schema(
+        description = "The accession of the sequence within the cited SeqSet. Can be either versioned or unversioned.",
+        type = "string",
+        example = "PP_123456.1",
+    )
+    val sequenceAccession: String,
+)
+
+@Schema(description = "A citation of a sequence.")
+data class SequenceCitation(val source: CitationSource, val seqSets: List<SeqSetCitingSequence>)
+
 data class ResponseSeqSet(val seqSetId: String, val seqSetVersion: Long)
 
 data class CitedBy(

backend/src/main/kotlin/org/loculus/backend/config/SecurityConfig.kt

@@ -56,6 +56,7 @@ class SecurityConfig {
         "/get-seqset",
         "/get-seqset-records",
         "/get-seqset-citations",
+        "/get-sequence-citations",
         "/get-author",
         "/*/get-released-data",
         "/files/get/**",

backend/src/main/kotlin/org/loculus/backend/controller/SeqSetCitationsController.kt

@@ -2,12 +2,14 @@ package org.loculus.backend.controller
 
 import io.swagger.v3.oas.annotations.Operation
 import io.swagger.v3.oas.annotations.security.SecurityRequirement
+import org.loculus.backend.api.AccessionVersion
 import org.loculus.backend.api.AuthorProfile
 import org.loculus.backend.api.CitedBy
 import org.loculus.backend.api.ResponseSeqSet
 import org.loculus.backend.api.SeqSet
 import org.loculus.backend.api.SeqSetCitation
 import org.loculus.backend.api.SeqSetRecord
+import org.loculus.backend.api.SequenceCitation
 import org.loculus.backend.api.SubmittedSeqSet
 import org.loculus.backend.api.SubmittedSeqSetRecord
 import org.loculus.backend.api.SubmittedSeqSetUpdate
@@ -109,6 +111,11 @@ class SeqSetCitationsController(
     fun getSeqSetCitations(@RequestParam seqSetId: String, @RequestParam version: Long): List<SeqSetCitation> =
         seqSetCitationsService.getSeqSetCitations(seqSetId, version)
 
+    @Operation(description = "Get sequence citations from publications or other sources")
+    @GetMapping("/get-sequence-citations")
+    fun getSequenceCitations(@RequestParam accession: String, @RequestParam version: Long?): List<SequenceCitation> =
+        seqSetCitationsService.getSequenceCitations(accession, version)
+
     @Operation(description = "Get an author")
     @GetMapping("/get-author")
     fun getAuthor(@RequestParam username: String): AuthorProfile {

backend/src/main/kotlin/org/loculus/backend/service/seqsetcitations/SeqSetCitationsDatabaseService.kt

@@ -7,8 +7,12 @@ import kotlinx.datetime.toLocalDateTime
 import mu.KotlinLogging
 import org.jetbrains.exposed.sql.Database
 import org.jetbrains.exposed.sql.JoinType
+import org.jetbrains.exposed.sql.LikePattern
+import org.jetbrains.exposed.sql.Op
 import org.jetbrains.exposed.sql.SortOrder
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.inList
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.like
 import org.jetbrains.exposed.sql.alias
 import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.andWhere
@@ -17,6 +21,7 @@ import org.jetbrains.exposed.sql.batchUpsert
 import org.jetbrains.exposed.sql.deleteWhere
 import org.jetbrains.exposed.sql.insert
 import org.jetbrains.exposed.sql.max
+import org.jetbrains.exposed.sql.or
 import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.update
 import org.keycloak.representations.idm.UserRepresentation
@@ -30,7 +35,9 @@ import org.loculus.backend.api.SeqSet
 import org.loculus.backend.api.SeqSetCitation
 import org.loculus.backend.api.SeqSetCitationSource
 import org.loculus.backend.api.SeqSetCitationsConstants
+import org.loculus.backend.api.SeqSetCitingSequence
 import org.loculus.backend.api.SeqSetRecord
+import org.loculus.backend.api.SequenceCitation
 import org.loculus.backend.api.Status.APPROVED_FOR_RELEASE
 import org.loculus.backend.api.SubmittedSeqSetRecord
 import org.loculus.backend.auth.AuthenticatedUser
@@ -531,6 +538,53 @@ class SeqSetCitationsDatabaseService(
             }
     }
 
+    fun getSequenceCitations(accession: String, version: Long?): List<SequenceCitation> {
+        log.info { "Get sequence citations for accession ${accession}${version?.let { ", version $it" } ?: ""}" }
+
+        // If a version is provided, return citations pinned to that exact accession and version
+        // Otherwise, return all citations for the accession, regardless of version, including unversioned
+        // NOTE: In this table, the 'accession' column can contain both accessions and accessionVersions
+        val accessionQuery: Op<Boolean> = if (version != null) {
+            val accessionVersion = AccessionVersion(accession, version)
+            SeqSetRecordsTable.accession eq accessionVersion.displayAccessionVersion()
+        } else {
+            (SeqSetRecordsTable.accession eq accession) or
+                (SeqSetRecordsTable.accession like (LikePattern.ofLiteral("$accession.") + "%"))
+        }
+
+        return SeqSetCitationSourceTable.innerJoin(
+            SeqSetToCitationSourceTable,
+        ).innerJoin(
+            SeqSetsTable,
+        ).innerJoin(SeqSetToRecordsTable).innerJoin(SeqSetRecordsTable).selectAll()
+            .where { accessionQuery }
+            .orderBy(
+                SeqSetCitationSourceTable.year to SortOrder.DESC,
+                SeqSetCitationSourceTable.citationSourceId to SortOrder.DESC,
+            )
+            .groupBy { it[SeqSetCitationSourceTable.citationSourceId] }
+            .map { (_, rows) ->
+                val first = rows.first()
+                SequenceCitation(
+                    source = CitationSource(
+                        sourceDOI = first[SeqSetCitationSourceTable.sourceDOI],
+                        title = first[SeqSetCitationSourceTable.title],
+                        year = first[SeqSetCitationSourceTable.year],
+                        contributors = first[SeqSetCitationSourceTable.contributors],
+                    ),
+                    seqSets = rows.map {
+                        SeqSetCitingSequence(
+                            seqSetAccessionVersion = AccessionVersion(
+                                it[SeqSetsTable.seqSetId],
+                                it[SeqSetsTable.seqSetVersion],
+                            ).displayAccessionVersion(),
+                            sequenceAccession = it[SeqSetRecordsTable.accession],
+                        )
+                    },
+                )
+            }
+    }
+
     fun validateSeqSetRecords(seqSetRecords: List<SubmittedSeqSetRecord>) {
         if (seqSetRecords.isEmpty()) {
             throw UnprocessableEntityException(

backend/src/test/kotlin/org/loculus/backend/controller/seqsetcitations/CitationEndpointsTest.kt

@@ -4,6 +4,7 @@ import com.jayway.jsonpath.JsonPath
 import com.ninjasquad.springmockk.MockkBean
 import io.mockk.every
 import org.hamcrest.CoreMatchers.containsString
+import org.hamcrest.Matchers.containsInAnyOrder
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.params.ParameterizedTest
@@ -192,6 +193,41 @@ class CitationEndpointsTest(
             )
     }
 
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("sequenceCitationVersionCases")
+    fun `WHEN getting sequence citations`(case: SequenceCitationVersionCase) {
+        val citations = case.citationsMap.map { (accession, citingSourceDOI) ->
+            val seqSetRecords = """[{ "accession": "$accession", "type": "loculus" }]"""
+            val result = client.createSeqSet(seqSetRecords = seqSetRecords).andExpect(status().isOk).andReturn()
+            val seqSetId = JsonPath.read<String>(result.response.contentAsString, "$.seqSetId")
+            val seqSetVersion = JsonPath.read<Int>(result.response.contentAsString, "$.seqSetVersion").toLong()
+            client.createSeqSetDOI(seqSetId = seqSetId, seqSetVersion = seqSetVersion).andExpect(status().isOk)
+            SeqSetCitationSource(
+                CitationSource(
+                    sourceDOI = citingSourceDOI,
+                    title = "A paper citing $accession",
+                    year = 2024,
+                    contributors = listOf(CitationContributor(givenName = "Jane", surname = "Doe")),
+                ),
+                seqSetDOIs = setOf("$MOCK_DOI_PREFIX/$seqSetId.$seqSetVersion"),
+            )
+        }
+
+        every { crossRefService.isActive } returns true
+        every { crossRefService.getCrossRefCitedBy(MOCK_DOI_PREFIX) } returns
+            CrossRefCitedByResult(citations, emptyList())
+        seqSetCrossRefCitationsTask.task()
+
+        client.getSequenceCitations(accession = case.accession, version = case.version)
+            .andExpect(status().isOk)
+            .andExpect(content().contentType(MediaType.APPLICATION_JSON_VALUE))
+            .andExpect(jsonPath("\$").isArray)
+            .andExpect(jsonPath("\$.length()").value(case.expectedCitingSourceDOIs.size))
+            .andExpect(
+                jsonPath("\$[*].source.sourceDOI", containsInAnyOrder(*case.expectedCitingSourceDOIs.toTypedArray())),
+            )
+    }
+
     @Test
     fun `WHEN multiple crossref citation runs link the same citation source THEN all citations are recorded`() {
         fun createSeqSetWithDOI(): Triple<String, Long, String> {
@@ -250,9 +286,52 @@ class CitationEndpointsTest(
             val isModifying: Boolean,
         )
 
+        data class SequenceCitationVersionCase(
+            val description: String,
+            val citationsMap: Map<String, String>,
+            val accession: String,
+            val version: Long?,
+            val expectedCitingSourceDOIs: List<String>,
+        ) {
+            override fun toString() = description
+        }
+
         @JvmStatic
         fun authorizationTestCases(): List<Scenario> = listOf(
             Scenario({ jwt, client -> client.getUserCitedBySeqSet(jwt = jwt) }, false),
         )
+
+        @JvmStatic
+        fun sequenceCitationVersionCases(): List<SequenceCitationVersionCase> {
+            // Map of test accessions to citation source DOIs
+            val testAccessions = listOf(
+                MOCK_SEQ_ACCESSION,
+                "$MOCK_SEQ_ACCESSION.1",
+                "$MOCK_SEQ_ACCESSION.2",
+                "$MOCK_SEQ_ACCESSION-other.1",
+            )
+            val citationsMap = testAccessions.associateWith { "10.5678/paper-citing-$it" }
+
+            return listOf(
+                SequenceCitationVersionCase(
+                    description = "accession and version THEN returns citations for the exact accession version",
+                    citationsMap = citationsMap,
+                    accession = MOCK_SEQ_ACCESSION,
+                    version = 1L,
+                    expectedCitingSourceDOIs = listOf("10.5678/paper-citing-${MOCK_SEQ_ACCESSION}.1"),
+                ),
+                SequenceCitationVersionCase(
+                    description = "accession only THEN returns citations for all accession versions + unversioned",
+                    citationsMap = citationsMap,
+                    accession = MOCK_SEQ_ACCESSION,
+                    version = null,
+                    expectedCitingSourceDOIs = listOf(
+                        "10.5678/paper-citing-${MOCK_SEQ_ACCESSION}",
+                        "10.5678/paper-citing-${MOCK_SEQ_ACCESSION}.1",
+                        "10.5678/paper-citing-${MOCK_SEQ_ACCESSION}.2",
+                    ),
+                ),
+            )
+        }
     }
 }

backend/src/test/kotlin/org/loculus/backend/controller/seqsetcitations/SeqSetCitationsControllerClient.kt

@@ -128,6 +128,13 @@ class SeqSetCitationsControllerClient(private val mockMvc: MockMvc) {
             .param("version", seqSetVersion.toString()),
     )
 
+    fun getSequenceCitations(accession: String = MOCK_SEQ_ACCESSION, version: Long? = MOCK_SEQ_VERSION): ResultActions =
+        mockMvc.perform(
+            get("/get-sequence-citations")
+                .param("accession", accession)
+                .apply { version?.let { param("version", it.toString()) } },
+        )
+
     fun getAuthor(username: String): ResultActions = mockMvc.perform(
         get("/get-author")
             .param("username", username),

backend/src/test/kotlin/org/loculus/backend/service/crossref/CrossRefServiceTest.kt

@@ -326,7 +326,9 @@ class CrossRefServiceTest(
             val description: String,
             val xml: String,
             val expectedReasonContains: String,
-        )
+        ) {
+            override fun toString() = description
+        }
 
         @JvmStatic
         fun crossRefValidationErrorCases(): List<CrossRefValidationErrorCase> = listOf(

website/src/components/SeqSetCitations/CitationList.tsx

@@ -0,0 +1,56 @@
+import { useState, type FC } from 'react';
+
+import { CitationDetails, CitationTable } from './CitationTable';
+import type { SeqSetCitation, SequenceCitation } from '../../types/seqSetCitation';
+import { BaseDialog } from '../common/BaseDialog';
+import { Button } from '../common/Button';
+
+interface CitationListProps {
+    citations: SeqSetCitation[] | SequenceCitation[];
+    maxDisplayedCitations?: number;
+    modalTitle?: string;
+}
+
+const CitationList: FC<CitationListProps> = ({ citations, maxDisplayedCitations, modalTitle }) => {
+    const [isOpen, setIsOpen] = useState(false);
+    const displayCitationsModalButton = maxDisplayedCitations !== undefined && citations.length > maxDisplayedCitations;
+
+    return (
+        <div className='space-y-2'>
+            <BaseDialog
+                isOpen={isOpen}
+                onClose={() => setIsOpen(false)}
+                title={modalTitle ?? 'Citations'}
+                fullWidth={false}
+                className='min-h-[60vh]'
+            >
+                <CitationTable isLoading={false} error={null} citations={citations} />
+            </BaseDialog>
+            {citations.length > 0 ? (
+                <div className='space-y-2'>
+                    <ul className='space-y-4'>
+                        {(maxDisplayedCitations !== undefined
+                            ? citations.slice(0, maxDisplayedCitations)
+                            : citations
+                        ).map((citation: SeqSetCitation | SequenceCitation) => (
+                            <li key={citation.source.sourceDOI}>
+                                <CitationDetails citation={citation} className='text-sm' displayYear />
+                            </li>
+                        ))}
+                    </ul>
+                    {displayCitationsModalButton && (
+                        <Button className='text-sm hover:underline' onClick={() => setIsOpen(true)}>
+                            View all citations ({citations.length})...
+                        </Button>
+                    )}
+                </div>
+            ) : (
+                <div className='py-8 text-center'>
+                    <span>No citations found.</span>
+                </div>
+            )}
+        </div>
+    );
+};
+
+export default CitationList;