summaryrefslogtreecommitdiff
path: root/src/main/kotlin/dev/dnpm/etl/processor/output/KafkaMtbFileSender.kt
blob: 8c20b7c8a38b7da53dadb523f15301f7a32cce9b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/*
 * This file is part of ETL-Processor
 *
 * Copyright (c) 2023       Comprehensive Cancer Center Mainfranken
 * Copyright (c) 2025-2026  Paul-Christian Volkmer, Datenintegrationszentrum Philipps-Universität Marburg and Contributors
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

package dev.dnpm.etl.processor.output

import dev.dnpm.etl.processor.CustomMediaType
import dev.dnpm.etl.processor.config.KafkaProperties
import dev.dnpm.etl.processor.monitoring.RequestStatus
import dev.pcvolkmer.mv64e.mtb.Mtb
import dev.pcvolkmer.mv64e.mtb.MvhMetadata
import org.apache.kafka.clients.producer.ProducerRecord
import org.slf4j.LoggerFactory
import org.springframework.kafka.core.KafkaTemplate
import org.springframework.retry.support.RetryTemplate
import tools.jackson.databind.json.JsonMapper

class KafkaMtbFileSender(
    private val kafkaTemplate: KafkaTemplate<String, String>,
    private val kafkaProperties: KafkaProperties,
    private val retryTemplate: RetryTemplate,
    private val jsonMapper: JsonMapper,
) : MtbFileSender {
    private val logger = LoggerFactory.getLogger(KafkaMtbFileSender::class.java)

    override fun <T> send(request: MtbFileRequest<T>): MtbFileSender.Response {
        return try {
            return retryTemplate.execute<MtbFileSender.Response, Exception> {
                val record =
                    ProducerRecord(
                        kafkaProperties.outputTopic,
                        key(request),
                        jsonMapper.writeValueAsString(request.content),
                    )
                record.headers().add("requestId", request.requestId.value.toByteArray())
                record.headers().add("requestMethod", "POST".toByteArray())
                when (request) {
                    is DnpmV2MtbFileRequest ->
                        record
                            .headers()
                            .add(
                                "contentType",
                                CustomMediaType.APPLICATION_VND_DNPM_V2_MTB_JSON_VALUE.toByteArray(),
                            )
                }

                val result = kafkaTemplate.send(record)
                if (result.get() != null) {
                    logger.debug("Sent file via KafkaMtbFileSender")
                    MtbFileSender.Response(RequestStatus.UNKNOWN)
                } else {
                    MtbFileSender.Response(RequestStatus.ERROR)
                }
            }
        } catch (e: Exception) {
            logger.error("An error occurred sending to kafka", e)
            MtbFileSender.Response(RequestStatus.ERROR)
        }
    }

    override fun send(request: DeleteRequest): MtbFileSender.Response {
        val dummyMtbFile = Mtb.builder().metadata(MvhMetadata()).build()

        return try {
            return retryTemplate.execute<MtbFileSender.Response, Exception> {
                val record =
                    ProducerRecord(
                        kafkaProperties.outputTopic,
                        key(request),
                        jsonMapper.writeValueAsString(
                            DnpmV2MtbFileRequest(request.requestId, dummyMtbFile),
                        ),
                    )
                record.headers().add("requestId", request.requestId.value.toByteArray())
                record.headers().add("requestMethod", "DELETE".toByteArray())
                record
                    .headers()
                    .add(
                        "contentType",
                        CustomMediaType.APPLICATION_VND_DNPM_V2_MTB_JSON_VALUE.toByteArray(),
                    )
                val result = kafkaTemplate.send(record)
                if (result.get() != null) {
                    logger.debug("Sent deletion request via KafkaMtbFileSender")
                    MtbFileSender.Response(RequestStatus.UNKNOWN)
                } else {
                    MtbFileSender.Response(RequestStatus.ERROR)
                }
            }
        } catch (e: Exception) {
            logger.error("An error occurred sending to kafka", e)
            MtbFileSender.Response(RequestStatus.ERROR)
        }
    }

    override fun endpoint(): String =
        "${this.kafkaProperties.servers} (${this.kafkaProperties.outputTopic}/${this.kafkaProperties.outputResponseTopic})"

    private fun key(request: MtbRequest): String =
        when (request) {
            is DnpmV2MtbFileRequest -> "{\"pid\": \"${request.content.patient.id}\"}"
            is DeleteRequest -> "{\"pid\": \"${request.patientId.value}\"}"
            else ->
                throw IllegalArgumentException("Unsupported request type: ${request::class.simpleName}")
        }
}