loculus-project
diff --git a/‎backend/src/main/kotlin/org/loculus/backend/api/SeqSetCitations.kt‎
Lines changed: 14 additions & 0 deletions b/‎backend/src/main/kotlin/org/loculus/backend/api/SeqSetCitations.kt‎
Lines changed: 14 additions & 0 deletions
diff --git a/‎backend/src/main/kotlin/org/loculus/backend/controller/SeqSetCitationsController.kt‎
Lines changed: 20 additions & 0 deletions b/‎backend/src/main/kotlin/org/loculus/backend/controller/SeqSetCitationsController.kt‎
Lines changed: 20 additions & 0 deletions
diff --git a/‎backend/src/main/kotlin/org/loculus/backend/service/seqsetcitations/SeqSetCitationsDatabaseService.kt‎
Lines changed: 131 additions & 22 deletions b/‎backend/src/main/kotlin/org/loculus/backend/service/seqsetcitations/SeqSetCitationsDatabaseService.kt‎
Lines changed: 131 additions & 22 deletions
diff --git a/‎backend/src/test/kotlin/org/loculus/backend/controller/EndpointTestExtension.kt‎
Lines changed: 3 additions & 0 deletions b/‎backend/src/test/kotlin/org/loculus/backend/controller/EndpointTestExtension.kt‎
Lines changed: 3 additions & 0 deletions
@@ -115,6 +115,20 @@ data class SeqSetCitingSequence(
 @Schema(description = "A citation of a sequence.")
 data class SequenceCitation(val source: CitationSource, val seqSets: List<SeqSetCitingSequence>)
 
+@Schema(description = "A citation of one or more SeqSets, with the SeqSets it references.")
+data class AdminSeqSetCitation(val source: CitationSource, val seqSets: List<SeqSet>, val origin: CitationOrigin)
+
+@Schema(description = "A request to manually register a publication or other source as citing one or more SeqSets.")
+data class AddSeqSetCitationRequest(
+    val source: CitationSource,
+    @Schema(
+        description = "Accession versions of the SeqSets that this source cites.",
+        type = "array",
+        example = "[\"PP_SS_1.1\"]",
+    )
+    val seqSetAccessionVersions: List<String>,
+)
+
 data class ResponseSeqSet(val seqSetId: String, val seqSetVersion: Long)
 
 data class AuthorProfile(
 
@@ -3,6 +3,8 @@ 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.AddSeqSetCitationRequest
+import org.loculus.backend.api.AdminSeqSetCitation
 import org.loculus.backend.api.AuthorProfile
 import org.loculus.backend.api.ResponseSeqSet
 import org.loculus.backend.api.SeqSet
@@ -101,6 +103,24 @@ class SeqSetCitationsController(
     fun getSeqSetCitations(@RequestParam seqSetId: String, @RequestParam version: Long): List<SeqSetCitation> =
         seqSetCitationsService.getSeqSetCitations(seqSetId, version)
 
+    @Operation(description = "Get all citations to all SeqSets in this instance. Restricted to super users.")
+    @GetMapping("/admin/get-all-seqset-citations")
+    fun getAllSeqSetCitations(): List<AdminSeqSetCitation> = seqSetCitationsService.getAllSeqSetCitations()
+
+    @Operation(
+        description = "Manually register a publication or other source as citing one or more SeqSets. " +
+            "Restricted to super users.",
+    )
+    @PostMapping("/admin/add-seqset-citation")
+    fun addSeqSetCitation(@RequestBody body: AddSeqSetCitationRequest): AdminSeqSetCitation =
+        seqSetCitationsService.addCuratedCitation(body)
+
+    @Operation(
+        description = "Delete a manually registered SeqSet citation by its source DOI. Restricted to super users.",
+    )
+    @DeleteMapping("/admin/delete-seqset-citation")
+    fun deleteSeqSetCitation(@RequestParam sourceDOI: String) = seqSetCitationsService.deleteCuratedCitation(sourceDOI)
+
     @Operation(description = "Get sequence citations from publications or other sources")
     @GetMapping("/get-sequence-citations")
     fun getSequenceCitations(@RequestParam accession: String, @RequestParam version: Long?): List<SequenceCitation> =
 
@@ -8,6 +8,7 @@ import mu.KotlinLogging
 import org.jetbrains.exposed.sql.Database
 import org.jetbrains.exposed.sql.LikePattern
 import org.jetbrains.exposed.sql.Op
+import org.jetbrains.exposed.sql.ResultRow
 import org.jetbrains.exposed.sql.SortOrder
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.inList
@@ -24,6 +25,8 @@ import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.update
 import org.keycloak.representations.idm.UserRepresentation
 import org.loculus.backend.api.AccessionVersion
+import org.loculus.backend.api.AddSeqSetCitationRequest
+import org.loculus.backend.api.AdminSeqSetCitation
 import org.loculus.backend.api.AuthorProfile
 import org.loculus.backend.api.CitationOrigin
 import org.loculus.backend.api.CitationSource
@@ -59,6 +62,16 @@ data class CitationSourcesUpdateResult(val updatedCitationSourceDOIs: Set<String
 
 data class SeqSetToCitationSourceEntry(val citationSourceId: Long, val seqSetId: String, val seqSetVersion: Long)
 
+private fun ResultRow.toSeqSet() = SeqSet(
+    seqSetId = this[SeqSetsTable.seqSetId],
+    seqSetVersion = this[SeqSetsTable.seqSetVersion],
+    name = this[SeqSetsTable.name],
+    createdAt = Timestamp.valueOf(this[SeqSetsTable.createdAt].toJavaLocalDateTime()),
+    createdBy = this[SeqSetsTable.createdBy],
+    description = this[SeqSetsTable.description],
+    seqSetDOI = this[SeqSetsTable.seqSetDOI],
+)
+
 @Service
 @Transactional
 class SeqSetCitationsDatabaseService(
@@ -211,17 +224,7 @@ class SeqSetCitationsDatabaseService(
             throw NotFoundException("SeqSet $seqSetId, version $version does not exist")
         }
 
-        return query.map { row ->
-            SeqSet(
-                row[SeqSetsTable.seqSetId],
-                row[SeqSetsTable.seqSetVersion],
-                row[SeqSetsTable.name],
-                Timestamp.valueOf(row[SeqSetsTable.createdAt].toJavaLocalDateTime()),
-                row[SeqSetsTable.createdBy],
-                row[SeqSetsTable.description],
-                row[SeqSetsTable.seqSetDOI],
-            )
-        }
+        return query.map { it.toSeqSet() }
     }
 
     fun getSeqSetRecords(seqSetId: String, version: Long?): List<SeqSetRecord> {
@@ -276,17 +279,7 @@ class SeqSetCitationsDatabaseService(
             .selectAll()
             .where { SeqSetsTable.createdBy eq username }
 
-        return selectedSeqSets.map {
-            SeqSet(
-                it[SeqSetsTable.seqSetId],
-                it[SeqSetsTable.seqSetVersion],
-                it[SeqSetsTable.name],
-                Timestamp.valueOf(it[SeqSetsTable.createdAt].toJavaLocalDateTime()),
-                it[SeqSetsTable.createdBy],
-                it[SeqSetsTable.description],
-                it[SeqSetsTable.seqSetDOI],
-            )
-        }
+        return selectedSeqSets.map { it.toSeqSet() }
     }
 
     fun deleteSeqSet(authenticatedUser: AuthenticatedUser, seqSetId: String, version: Long) {
@@ -515,6 +508,122 @@ class SeqSetCitationsDatabaseService(
             }
     }
 
+    fun getAllSeqSetCitations(): List<AdminSeqSetCitation> {
+        log.info { "Get all seqSet citations" }
+
+        return SeqSetCitationSourceTable.innerJoin(
+            SeqSetToCitationSourceTable,
+        ).innerJoin(
+            SeqSetsTable,
+        ).selectAll()
+            .orderBy(
+                SeqSetCitationSourceTable.year to SortOrder.DESC,
+                SeqSetCitationSourceTable.citationSourceId to SortOrder.DESC,
+            )
+            .groupBy { it[SeqSetCitationSourceTable.citationSourceId] }
+            .map { (_, rows) ->
+                val first = rows.first()
+                AdminSeqSetCitation(
+                    source = CitationSource(
+                        sourceDOI = first[SeqSetCitationSourceTable.sourceDOI],
+                        title = first[SeqSetCitationSourceTable.title],
+                        year = first[SeqSetCitationSourceTable.year],
+                        contributors = first[SeqSetCitationSourceTable.contributors],
+                    ),
+                    seqSets = rows.map { it.toSeqSet() },
+                    origin = first[SeqSetCitationSourceTable.origin],
+                )
+            }
+    }
+
+    fun addCuratedCitation(request: AddSeqSetCitationRequest): AdminSeqSetCitation {
+        log.info { "Add curated seqSet citation ${request.source.sourceDOI}" }
+
+        if (request.source.sourceDOI.isBlank()) {
+            throw UnprocessableEntityException("Citation source DOI must not be empty")
+        }
+        if (request.source.title.isBlank()) {
+            throw UnprocessableEntityException("Citation source title must not be empty")
+        }
+        if (request.seqSetAccessionVersions.isEmpty()) {
+            throw UnprocessableEntityException("At least one cited SeqSet must be provided")
+        }
+
+        val existingOrigin = SeqSetCitationSourceTable
+            .select(SeqSetCitationSourceTable.origin)
+            .where { SeqSetCitationSourceTable.sourceDOI eq request.source.sourceDOI }
+            .singleOrNull()
+            ?.get(SeqSetCitationSourceTable.origin)
+        if (existingOrigin == CitationOrigin.CROSSREF) {
+            throw UnprocessableEntityException(
+                "Citation source ${request.source.sourceDOI} was discovered via CrossRef and cannot be modified manually",
+            )
+        }
+
+        val accessionVersions = request.seqSetAccessionVersions.map { AccessionVersion.fromString(it) }
+
+        val existingSeqSets = SeqSetsTable
+            .select(SeqSetsTable.seqSetId, SeqSetsTable.seqSetVersion, SeqSetsTable.name, SeqSetsTable.seqSetDOI)
+            .where {
+                Pair(SeqSetsTable.seqSetId, SeqSetsTable.seqSetVersion) inList
+                    accessionVersions.map { it.accession to it.version }
+            }
+            .associateBy { AccessionVersion(it[SeqSetsTable.seqSetId], it[SeqSetsTable.seqSetVersion]) }
+
+        val missing = accessionVersions.filterNot { it in existingSeqSets }
+        if (missing.isNotEmpty()) {
+            throw NotFoundException(
+                "The following SeqSets do not exist: ${missing.joinToString(", ") { it.displayAccessionVersion() }}",
+            )
+        }
+
+        val citationSourceId = SeqSetCitationSourceTable
+            .batchUpsert(listOf(request.source), SeqSetCitationSourceTable.sourceDOI) {
+                this[SeqSetCitationSourceTable.sourceDOI] = it.sourceDOI
+                this[SeqSetCitationSourceTable.origin] = CitationOrigin.CURATED
+                this[SeqSetCitationSourceTable.title] = it.title
+                this[SeqSetCitationSourceTable.year] = it.year
+                this[SeqSetCitationSourceTable.contributors] = it.contributors
+            }
+            .single()[SeqSetCitationSourceTable.citationSourceId]
+
+        SeqSetToCitationSourceTable.batchInsert(accessionVersions, ignore = true) { accessionVersion ->
+            this[SeqSetToCitationSourceTable.citationSourceId] = citationSourceId
+            this[SeqSetToCitationSourceTable.seqSetId] = accessionVersion.accession
+            this[SeqSetToCitationSourceTable.seqSetVersion] = accessionVersion.version
+        }
+
+        val linkedSeqSets = SeqSetToCitationSourceTable
+            .innerJoin(SeqSetsTable)
+            .selectAll()
+            .where { SeqSetToCitationSourceTable.citationSourceId eq citationSourceId }
+            .map { it.toSeqSet() }
+
+        return AdminSeqSetCitation(
+            source = request.source,
+            seqSets = linkedSeqSets,
+            origin = CitationOrigin.CURATED,
+        )
+    }
+
+    fun deleteCuratedCitation(sourceDOI: String) {
+        log.info { "Delete curated seqSet citation $sourceDOI" }
+
+        val citationSource = SeqSetCitationSourceTable
+            .selectAll()
+            .where { SeqSetCitationSourceTable.sourceDOI eq sourceDOI }
+            .singleOrNull()
+            ?: throw NotFoundException("Citation source $sourceDOI does not exist")
+
+        if (citationSource[SeqSetCitationSourceTable.origin] != CitationOrigin.CURATED) {
+            throw UnprocessableEntityException(
+                "Citation source $sourceDOI was not manually curated and cannot be deleted",
+            )
+        }
+
+        SeqSetCitationSourceTable.deleteWhere { SeqSetCitationSourceTable.sourceDOI eq sourceDOI }
+    }
+
     fun validateSeqSetRecords(seqSetRecords: List<SubmittedSeqSetRecord>) {
         if (seqSetRecords.isEmpty()) {
             throw UnprocessableEntityException(
 
@@ -244,6 +244,8 @@ private fun clearDatabaseStatement(): String = """
             seqsets,
             seqset_records,
             seqset_to_records,
+            seqset_citation_source,
+            seqset_to_citation_source,
             audit_log,
             table_update_tracker,
             task_lock
@@ -253,6 +255,7 @@ private fun clearDatabaseStatement(): String = """
         alter sequence seqset_id_sequence restart with 1;
         alter sequence seqset_records_seqset_record_id_seq restart with 1;
         alter sequence seqset_to_records_seqset_record_id_seq restart with 1;
+        alter sequence seqset_citation_source_citation_source_id_seq restart with 1;
         alter sequence user_groups_table_id_seq restart with 1;
         alter sequence audit_log_id_seq restart with 1;
         insert into $CURRENT_PROCESSING_PIPELINE_TABLE_NAME values