fix(backend): return open data use terms url in get-released-data when data is open

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

@@ -72,13 +72,15 @@ class BackendSpringConfig {
     fun backendConfig(
         objectMapper: ObjectMapper,
         @Value("\${${BackendSpringProperty.BACKEND_CONFIG_PATH}}") configPath: String,
-    ): BackendConfig {
-        val config = objectMapper.readValue<BackendConfig>(File(configPath))
-        logger.info { "Loaded backend config from $configPath" }
-        logger.info { "Config: $config" }
-        return objectMapper.readValue(File(configPath))
-    }
+    ): BackendConfig = readBackendConfig(objectMapper, configPath)
 
     @Bean
     fun openApi(backendConfig: BackendConfig) = buildOpenApiSchema(backendConfig)
 }
+
+fun readBackendConfig(objectMapper: ObjectMapper, configPath: String): BackendConfig {
+    val config = objectMapper.readValue<BackendConfig>(File(configPath))
+    logger.info { "Loaded backend config from $configPath" }
+    logger.info { "Config: $config" }
+    return objectMapper.readValue(File(configPath))
+}

backend/src/main/kotlin/org/loculus/backend/model/ReleasedDataModel.kt

@@ -5,9 +5,6 @@ import com.fasterxml.jackson.databind.node.IntNode
 import com.fasterxml.jackson.databind.node.LongNode
 import com.fasterxml.jackson.databind.node.NullNode
 import com.fasterxml.jackson.databind.node.TextNode
-import kotlinx.datetime.Clock
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toLocalDateTime
 import mu.KotlinLogging
 import org.loculus.backend.api.DataUseTerms
 import org.loculus.backend.api.GeneticSequence
@@ -19,6 +16,7 @@ import org.loculus.backend.service.submission.RawProcessedData
 import org.loculus.backend.service.submission.SubmissionDatabaseService
 import org.loculus.backend.service.submission.UpdateTrackerTable
 import org.loculus.backend.utils.Accession
+import org.loculus.backend.utils.DateProvider
 import org.loculus.backend.utils.Version
 import org.loculus.backend.utils.toTimestamp
 import org.loculus.backend.utils.toUtcDateString
@@ -41,6 +39,7 @@ val RELEASED_DATA_RELATED_TABLES: List<String> =
 open class ReleasedDataModel(
     private val submissionDatabaseService: SubmissionDatabaseService,
     private val backendConfig: BackendConfig,
+    private val dateProvider: DateProvider,
 ) {
     @Transactional(readOnly = true)
     open fun getReleasedData(organism: Organism): Sequence<ProcessedData<GeneticSequence>> {
@@ -85,31 +84,35 @@ open class ReleasedDataModel(
         }
 
         var metadata = rawProcessedData.processedData.metadata +
-            ("accession" to TextNode(rawProcessedData.accession)) +
-            ("version" to LongNode(rawProcessedData.version)) +
-            (HEADER_TO_CONNECT_METADATA_AND_SEQUENCES to TextNode(rawProcessedData.submissionId)) +
-            ("accessionVersion" to TextNode(rawProcessedData.displayAccessionVersion())) +
-            ("isRevocation" to BooleanNode.valueOf(rawProcessedData.isRevocation)) +
-            ("submitter" to TextNode(rawProcessedData.submitter)) +
-            ("groupId" to IntNode(rawProcessedData.groupId)) +
-            ("groupName" to TextNode(rawProcessedData.groupName)) +
-            ("submittedDate" to TextNode(rawProcessedData.submittedAtTimestamp.toUtcDateString())) +
-            ("submittedAtTimestamp" to LongNode(rawProcessedData.submittedAtTimestamp.toTimestamp())) +
-            ("releasedAtTimestamp" to LongNode(rawProcessedData.releasedAtTimestamp.toTimestamp())) +
-            ("releasedDate" to TextNode(rawProcessedData.releasedAtTimestamp.toUtcDateString())) +
-            ("versionStatus" to TextNode(versionStatus.name)) +
-            ("dataUseTerms" to TextNode(currentDataUseTerms.type.name)) +
-            ("dataUseTermsRestrictedUntil" to restrictedDataUseTermsUntil) +
-            ("versionComment" to TextNode(rawProcessedData.versionComment))
-
-        if (backendConfig.dataUseTermsUrls != null) {
-            val url = if (rawProcessedData.dataUseTerms == DataUseTerms.Open) {
-                backendConfig.dataUseTermsUrls.open
-            } else {
-                backendConfig.dataUseTermsUrls.restricted
+            mapOf(
+                ("accession" to TextNode(rawProcessedData.accession)),
+                ("version" to LongNode(rawProcessedData.version)),
+                (HEADER_TO_CONNECT_METADATA_AND_SEQUENCES to TextNode(rawProcessedData.submissionId)),
+                ("accessionVersion" to TextNode(rawProcessedData.displayAccessionVersion())),
+                ("isRevocation" to BooleanNode.valueOf(rawProcessedData.isRevocation)),
+                ("submitter" to TextNode(rawProcessedData.submitter)),
+                ("groupId" to IntNode(rawProcessedData.groupId)),
+                ("groupName" to TextNode(rawProcessedData.groupName)),
+                ("submittedDate" to TextNode(rawProcessedData.submittedAtTimestamp.toUtcDateString())),
+                ("submittedAtTimestamp" to LongNode(rawProcessedData.submittedAtTimestamp.toTimestamp())),
+                ("releasedAtTimestamp" to LongNode(rawProcessedData.releasedAtTimestamp.toTimestamp())),
+                ("releasedDate" to TextNode(rawProcessedData.releasedAtTimestamp.toUtcDateString())),
+                ("versionStatus" to TextNode(versionStatus.name)),
+                ("dataUseTerms" to TextNode(currentDataUseTerms.type.name)),
+                ("dataUseTermsRestrictedUntil" to restrictedDataUseTermsUntil),
+                ("versionComment" to TextNode(rawProcessedData.versionComment)),
+            ).let {
+                when (backendConfig.dataUseTermsUrls) {
+                    null -> it
+                    else -> {
+                        val url = when (currentDataUseTerms) {
+                            DataUseTerms.Open -> backendConfig.dataUseTermsUrls.open
+                            is DataUseTerms.Restricted -> backendConfig.dataUseTermsUrls.restricted
+                        }
+                        it + ("dataUseTermsUrl" to TextNode(url))
+                    }
+                }
             }
-            metadata += ("dataUseTermsUrl" to TextNode(url))
-        }
 
         return ProcessedData(
             metadata = metadata,
@@ -123,7 +126,7 @@ open class ReleasedDataModel(
 
     private fun computeDataUseTerm(rawProcessedData: RawProcessedData): DataUseTerms = if (
         rawProcessedData.dataUseTerms is DataUseTerms.Restricted &&
-        rawProcessedData.dataUseTerms.restrictedUntil > Clock.System.now().toLocalDateTime(TimeZone.UTC).date
+        rawProcessedData.dataUseTerms.restrictedUntil > dateProvider.getCurrentDate()
     ) {
         DataUseTerms.Restricted(rawProcessedData.dataUseTerms.restrictedUntil)
     } else {

backend/src/main/kotlin/org/loculus/backend/model/SubmitModel.kt

@@ -1,8 +1,5 @@
 package org.loculus.backend.model
 
-import kotlinx.datetime.Clock
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toLocalDateTime
 import mu.KotlinLogging
 import org.apache.commons.compress.archivers.zip.ZipFile
 import org.apache.commons.compress.compressors.CompressorStreamFactory
@@ -20,6 +17,7 @@ import org.loculus.backend.service.submission.CompressionAlgorithm
 import org.loculus.backend.service.submission.MetadataUploadAuxTable
 import org.loculus.backend.service.submission.SequenceUploadAuxTable
 import org.loculus.backend.service.submission.UploadDatabaseService
+import org.loculus.backend.utils.DateProvider
 import org.loculus.backend.utils.FastaReader
 import org.loculus.backend.utils.metadataEntryStreamAsSequence
 import org.loculus.backend.utils.revisionEntryStreamAsSequence
@@ -77,6 +75,7 @@ class SubmitModel(
     private val uploadDatabaseService: UploadDatabaseService,
     private val groupManagementPreconditionValidator: GroupManagementPreconditionValidator,
     private val dataUseTermsPreconditionValidator: DataUseTermsPreconditionValidator,
+    private val dateProvider: DateProvider,
 ) {
 
     companion object AcceptedFileTypes {
@@ -212,7 +211,7 @@ class SubmitModel(
             "intermediate storing uploaded metadata of type ${submissionParams.uploadType.name} " +
                 "from $submissionParams.submitter with UploadId $uploadId"
         }
-        val now = Clock.System.now().toLocalDateTime(TimeZone.UTC)
+        val now = dateProvider.getCurrentDateTime()
         try {
             when (submissionParams) {
                 is SubmissionParams.OriginalSubmissionParams -> {

backend/src/main/kotlin/org/loculus/backend/service/datauseterms/DataUseTermsDatabaseService.kt

@@ -1,8 +1,5 @@
 package org.loculus.backend.service.datauseterms
 
-import kotlinx.datetime.Clock
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toLocalDateTime
 import org.jetbrains.exposed.sql.batchInsert
 import org.jetbrains.exposed.sql.selectAll
 import org.loculus.backend.api.DataUseTerms
@@ -13,6 +10,7 @@ import org.loculus.backend.controller.NotFoundException
 import org.loculus.backend.log.AuditLogger
 import org.loculus.backend.service.submission.AccessionPreconditionValidator
 import org.loculus.backend.utils.Accession
+import org.loculus.backend.utils.DateProvider
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 
@@ -22,14 +20,15 @@ class DataUseTermsDatabaseService(
     private val accessionPreconditionValidator: AccessionPreconditionValidator,
     private val dataUseTermsPreconditionValidator: DataUseTermsPreconditionValidator,
     private val auditLogger: AuditLogger,
+    private val dateProvider: DateProvider,
 ) {
 
     fun setNewDataUseTerms(
         authenticatedUser: AuthenticatedUser,
         accessions: List<Accession>,
         newDataUseTerms: DataUseTerms,
     ) {
-        val now = Clock.System.now().toLocalDateTime(TimeZone.UTC)
+        val now = dateProvider.getCurrentDateTime()
 
         accessionPreconditionValidator.validate {
             thatAccessionsExist(accessions)

backend/src/main/kotlin/org/loculus/backend/service/datauseterms/DataUseTermsPreconditionValidator.kt

@@ -1,23 +1,21 @@
 package org.loculus.backend.service.datauseterms
 
-import kotlinx.datetime.Clock
 import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.TimeZone
 import kotlinx.datetime.plus
-import kotlinx.datetime.toLocalDateTime
 import mu.KotlinLogging
 import org.jetbrains.exposed.sql.and
 import org.loculus.backend.api.DataUseTerms
 import org.loculus.backend.api.DataUseTermsType
 import org.loculus.backend.controller.BadRequestException
 import org.loculus.backend.controller.UnprocessableEntityException
 import org.loculus.backend.utils.Accession
+import org.loculus.backend.utils.DateProvider
 import org.springframework.stereotype.Component
 
 private val logger = KotlinLogging.logger { }
 
 @Component
-class DataUseTermsPreconditionValidator {
+class DataUseTermsPreconditionValidator(private val dateProvider: DateProvider) {
 
     fun checkThatTransitionIsAllowed(accessions: List<Accession>, newDataUseTerms: DataUseTerms) {
         val dataUseTerms = DataUseTermsTable
@@ -54,7 +52,7 @@ class DataUseTermsPreconditionValidator {
 
     fun checkThatRestrictedUntilIsAllowed(dataUseTerms: DataUseTerms) {
         if (dataUseTerms is DataUseTerms.Restricted) {
-            val now = Clock.System.now().toLocalDateTime(TimeZone.UTC).date
+            val now = dateProvider.getCurrentDate()
             val oneYearFromNow = now.plus(1, DateTimeUnit.YEAR)
 
             if (dataUseTerms.restrictedUntil < now) {

backend/src/main/kotlin/org/loculus/backend/service/debug/DeleteSequenceDataService.kt

@@ -1,8 +1,5 @@
 package org.loculus.backend.service.debug
 
-import kotlinx.datetime.Clock
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toLocalDateTime
 import org.jetbrains.exposed.sql.deleteAll
 import org.jetbrains.exposed.sql.insert
 import org.loculus.backend.service.datauseterms.DataUseTermsTable
@@ -11,11 +8,12 @@ import org.loculus.backend.service.submission.MetadataUploadAuxTable
 import org.loculus.backend.service.submission.SequenceEntriesPreprocessedDataTable
 import org.loculus.backend.service.submission.SequenceEntriesTable
 import org.loculus.backend.service.submission.SequenceUploadAuxTable
+import org.loculus.backend.utils.DateProvider
 import org.springframework.stereotype.Component
 import org.springframework.transaction.annotation.Transactional
 
 @Component
-class DeleteSequenceDataService {
+class DeleteSequenceDataService(private val dateProvider: DateProvider) {
     @Transactional
     fun deleteAllSequenceData() {
         SequenceEntriesTable.deleteAll()
@@ -26,7 +24,7 @@ class DeleteSequenceDataService {
         CurrentProcessingPipelineTable.deleteAll()
         CurrentProcessingPipelineTable.insert {
             it[versionColumn] = 1
-            it[startedUsingAtColumn] = Clock.System.now().toLocalDateTime(TimeZone.UTC)
+            it[startedUsingAtColumn] = dateProvider.getCurrentDateTime()
         }
     }
 }

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

@@ -1,8 +1,7 @@
 package org.loculus.backend.service.seqsetcitations
 
-import kotlinx.datetime.Clock
-import kotlinx.datetime.LocalDateTime
-import kotlinx.datetime.TimeZone
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.minus
 import kotlinx.datetime.toJavaLocalDateTime
 import kotlinx.datetime.toLocalDateTime
 import mu.KotlinLogging
@@ -35,6 +34,7 @@ import org.loculus.backend.controller.UnprocessableEntityException
 import org.loculus.backend.service.crossref.CrossRefService
 import org.loculus.backend.service.crossref.DoiEntry
 import org.loculus.backend.service.submission.AccessionPreconditionValidator
+import org.loculus.backend.utils.DateProvider
 import org.loculus.backend.utils.getNextSequenceNumber
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
@@ -50,6 +50,7 @@ class SeqSetCitationsDatabaseService(
     private val accessionPreconditionValidator: AccessionPreconditionValidator,
     private val backendConfig: BackendConfig,
     private val crossRefService: CrossRefService,
+    private val dateProvider: DateProvider,
     pool: DataSource,
 ) {
     init {
@@ -69,16 +70,14 @@ class SeqSetCitationsDatabaseService(
         validateSeqSetName(seqSetName)
         validateSeqSetRecords(seqSetRecords)
 
-        val now = Clock.System.now().toLocalDateTime(TimeZone.UTC)
-
         val seqsetIdNumber = getNextSequenceNumber("seqset_id_sequence")
         val insertedSet = SeqSetsTable
             .insert {
                 it[seqSetId] = constructSeqsetId(seqsetIdNumber)
                 it[name] = seqSetName
                 it[description] = seqSetDescription ?: ""
                 it[seqSetVersion] = 1
-                it[createdAt] = now
+                it[createdAt] = dateProvider.getCurrentDateTime()
                 it[createdBy] = authenticatedUser.username
             }
 
@@ -116,8 +115,6 @@ class SeqSetCitationsDatabaseService(
         validateSeqSetName(seqSetName)
         validateSeqSetRecords(seqSetRecords)
 
-        val now = Clock.System.now().toLocalDateTime(TimeZone.UTC)
-
         val maxVersion = SeqSetsTable
             .select(SeqSetsTable.seqSetVersion.max())
             .where { SeqSetsTable.seqSetId eq seqSetId and (SeqSetsTable.createdBy eq username) }
@@ -144,7 +141,7 @@ class SeqSetCitationsDatabaseService(
                 it[SeqSetsTable.name] = seqSetName
                 it[SeqSetsTable.description] = seqSetDescription ?: ""
                 it[SeqSetsTable.seqSetVersion] = newVersion
-                it[SeqSetsTable.createdAt] = now
+                it[SeqSetsTable.createdAt] = dateProvider.getCurrentDateTime()
                 it[SeqSetsTable.createdBy] = username
             }
 
@@ -314,8 +311,8 @@ class SeqSetCitationsDatabaseService(
             throw NotFoundException("SeqSet $seqSetId, version $version does not exist")
         }
 
-        val now = Clock.System.now().toLocalDateTime(TimeZone.UTC).toJavaLocalDateTime()
-        val sevenDaysAgo = LocalDateTime.parse(now.minusDays(7).toString())
+        val now = dateProvider.getCurrentInstant()
+        val sevenDaysAgo = now.minus(7, DateTimeUnit.DAY, DateProvider.timeZone).toLocalDateTime(DateProvider.timeZone)
         val count = SeqSetsTable
             .selectAll()
             .where {