🚀 Fjerne translation tabell

src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/clients/oppfolging/Oppfolgingsperiode.kt

@@ -15,3 +15,9 @@ data class Oppfolgingsperiode (
 		return startetIPeriode && foerSluttDato
 	}
 }
+
+data class AvsluttetOppfolgingsperiode (
+	val uuid: UUID,
+	val startDato: ZonedDateTime,
+	val sluttDato: ZonedDateTime
+)

src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/domain/db/ArenaDataUpsertInput.kt

@@ -41,8 +41,8 @@ fun ArenaKafkaMessage<*>.toUpsertInputWithStatusHandled(arenaId: Long): ArenaDat
 	return this.toUpsertInput(arenaId.toString(), IngestStatus.HANDLED, null)
 }
 
-fun ArenaKafkaMessage<*>.toUpsertInputWithStatusHandled(arenaId: DeltakelseId): ArenaDataUpsertInput {
-	return this.toUpsertInput(arenaId.value.toString(), IngestStatus.HANDLED, null)
+fun ArenaKafkaMessage<*>.toUpsertInputWithStatusHandled(arenaId: DeltakelseId, note: String? = null): ArenaDataUpsertInput {
+	return this.toUpsertInput(arenaId.value.toString(), IngestStatus.HANDLED, note)
 }
 
 fun ArenaKafkaMessage<*>.toUpsertInputWithStatusHandled(arenaId: String): ArenaDataUpsertInput {

src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/domain/kafka/aktivitet/AktivitetKategori.kt

@@ -1,6 +1,7 @@
 package no.nav.arena_tiltak_aktivitet_acl.domain.kafka.aktivitet
 
-enum class AktivitetKategori {
-	TILTAKSAKTIVITET, UTDANNINGSAKTIVITET, GRUPPEAKTIVITET
-
+enum class AktivitetKategori(val prefix: String) {
+	TILTAKSAKTIVITET("ARENATA"),
+	UTDANNINGSAKTIVITET("ARENAUA"),
+	GRUPPEAKTIVITET("ARENAGA")
 }

src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/domain/kafka/aktivitet/AktivitetskortHeaders.kt

@@ -10,7 +10,7 @@ import java.util.*
 data class AktivitetskortHeaders(
 	val arenaId: String,
 	val tiltakKode: String,
-	val oppfolgingsperiode: UUID?,
+	val oppfolgingsperiode: UUID,
 	val oppfolgingsSluttDato: ZonedDateTime?,
 	)
 {

src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/processors/DeltakerProcessor.kt

@@ -1,7 +1,6 @@
 package no.nav.arena_tiltak_aktivitet_acl.processors
 
 import no.nav.arena_tiltak_aktivitet_acl.clients.oppfolging.Oppfolgingsperiode
-import no.nav.arena_tiltak_aktivitet_acl.domain.db.DeltakerAktivitetMappingDbo
 import no.nav.arena_tiltak_aktivitet_acl.domain.db.IngestStatus
 import no.nav.arena_tiltak_aktivitet_acl.domain.db.toUpsertInputWithStatusHandled
 import no.nav.arena_tiltak_aktivitet_acl.domain.kafka.aktivitet.AktivitetKategori
@@ -17,7 +16,6 @@ import no.nav.arena_tiltak_aktivitet_acl.exceptions.OppfolgingsperiodeNotFoundEx
 import no.nav.arena_tiltak_aktivitet_acl.exceptions.OutOfOrderException
 import no.nav.arena_tiltak_aktivitet_acl.processors.converters.ArenaDeltakerConverter
 import no.nav.arena_tiltak_aktivitet_acl.repositories.ArenaDataRepository
-import no.nav.arena_tiltak_aktivitet_acl.repositories.DeltakerAktivitetMappingRepository
 import no.nav.arena_tiltak_aktivitet_acl.repositories.GjennomforingRepository
 import no.nav.arena_tiltak_aktivitet_acl.services.*
 import no.nav.arena_tiltak_aktivitet_acl.services.OppfolgingsperiodeService.Companion.defaultSlakk
@@ -35,14 +33,12 @@ import java.util.*
 @Component
 open class DeltakerProcessor(
 	private val arenaDataRepository: ArenaDataRepository,
-	private val arenaIdArenaIdTilAktivitetskortIdService: ArenaIdTilAktivitetskortIdService,
 	private val kafkaProducerService: KafkaProducerService,
 	private val gjennomforingRepository: GjennomforingRepository,
 	private val aktivitetService: AktivitetService,
 	private val tiltakService: TiltakService,
 	private val personsporingService: PersonsporingService,
 	private val oppfolgingsperiodeService: OppfolgingsperiodeService,
-	private val deltakerAktivitetMappingRepository: DeltakerAktivitetMappingRepository
 ) : ArenaMessageProcessor<ArenaDeltakerKafkaMessage> {
 
 	companion object {
@@ -88,28 +84,18 @@ open class DeltakerProcessor(
 		 hopper vi ut her, enten med retry eller ignored, siden handleOppfolgingsperiodeNull kaster exception alltid.
 		 Dette er viktig for å ikke opprette ny aktivitetsid før vi faktisk lagrer et aktivitetskort.
 		*/
-		val oppfolgingsperiodePaaEndringsTidspunkt = getOppfolgingsPeriodeOrThrow(deltakelse, personIdent)
-		val endring = utledEndringsType(oppfolgingsperiodePaaEndringsTidspunkt, deltakelse.tiltakdeltakelseId, arenaDeltaker.DELTAKERSTATUSKODE, tiltak.administrasjonskode)
+		val periodeMatch = getOppfolgingsPeriodeOrThrow(deltakelse, personIdent)
+		val endring = utledEndringsType(periodeMatch, deltakelse.tiltakdeltakelseId, arenaDeltaker.DELTAKERSTATUSKODE, tiltak.administrasjonskode)
 		when (endring) {
 			is EndringsType.NyttAktivitetskortByttPeriode  -> {
-				secureLog.info("Endring på deltakelse ${deltakelse.tiltakdeltakelseId} på deltakerId ${deltakelse.tiltakdeltakelseId} til ny aktivitetsid ${endring.aktivitetskortId} og oppfølgingsperiode ${oppfolgingsperiodePaaEndringsTidspunkt}. " +
+				secureLog.info("Endring på deltakelse ${deltakelse.tiltakdeltakelseId} på deltakerId ${deltakelse.tiltakdeltakelseId} til ny aktivitetsid ${endring.aktivitetskortId} og oppfølgingsperiode ${periodeMatch.oppfolgingsperiode.uuid}. " +
 					"Oppretter nytt aktivitetskort for personIdent $personIdent og endrer eksisterende translation entry")
-				endring.oppdaterMappingMedNyId(deltakelse.tiltakdeltakelseId)
-				arenaIdArenaIdTilAktivitetskortIdService.setCurrentAktivitetskortIdForDeltakerId(deltakelse.tiltakdeltakelseId, endring.aktivitetskortId)
-			}
-			is EndringsType.NyttAktivitetskort -> {
-				arenaIdArenaIdTilAktivitetskortIdService.opprettAktivitetsId(endring.aktivitetskortId, deltakelse.tiltakdeltakelseId, AktivitetKategori.TILTAKSAKTIVITET)
-				endring.oppdaterMappingMedNyId(deltakelse.tiltakdeltakelseId)
+				syncOppfolgingsperioder(deltakelse.tiltakdeltakelseId, periodeMatch.allePerioder)
 			}
+			is EndringsType.NyttAktivitetskort -> {}
 			is EndringsType.OppdaterAktivitet -> {}
 		}
 
-		if (endring.skalIgnoreres) {
-			log.info("Deltakeren har status=${arenaDeltaker.DELTAKERSTATUSKODE} og administrasjonskode=${tiltak.administrasjonskode} som ikke skal håndteres")
-			arenaDataRepository.upsert(message.toUpsertInputWithStatusHandled(deltakelse.tiltakdeltakelseId))
-			return
-		}
-
 		val aktivitet = ArenaDeltakerConverter
 			.convertToTiltaksaktivitet(
 				deltaker = deltakelse,
@@ -122,13 +108,19 @@ open class DeltakerProcessor(
 		val aktivitetskortHeaders = AktivitetskortHeaders(
 			arenaId = "${KafkaProducerService.TILTAK_ID_PREFIX}${deltakelse.tiltakdeltakelseId}",
 			tiltakKode = tiltak.kode,
-			oppfolgingsperiode = oppfolgingsperiodePaaEndringsTidspunkt.uuid,
-			oppfolgingsSluttDato = oppfolgingsperiodePaaEndringsTidspunkt.sluttDato
+			oppfolgingsperiode = periodeMatch.oppfolgingsperiode.uuid,
+			oppfolgingsSluttDato = periodeMatch.oppfolgingsperiode.sluttDato
 		)
-		val outgoingMessage = aktivitet.toKafkaMessage()
 		aktivitetService.upsert(aktivitet, aktivitetskortHeaders)
-		arenaDataRepository.upsert(message.toUpsertInputWithStatusHandled(deltakelse.tiltakdeltakelseId))
 
+		if (endring.skalIgnoreres) {
+			log.info("Deltakeren har status=${arenaDeltaker.DELTAKERSTATUSKODE} og administrasjonskode=${tiltak.administrasjonskode} som ikke skal håndteres")
+			arenaDataRepository.upsert(message.toUpsertInputWithStatusHandled(deltakelse.tiltakdeltakelseId, "foreløpig ignorert"))
+			return
+		}
+
+		arenaDataRepository.upsert(message.toUpsertInputWithStatusHandled(deltakelse.tiltakdeltakelseId))
+		val outgoingMessage = aktivitet.toKafkaMessage()
 		secureLog.info("Sender melding for aktivitetskort id=${endring.aktivitetskortId} arenaId=${deltakelse.tiltakdeltakelseId} personId=${deltakelse.personId} fnr=$personIdent")
 		log.info("Sender medling messageId=${outgoingMessage.messageId} aktivitetskort id=$endring.aktivitetskortId  arenaId=${deltakelse.tiltakdeltakelseId} type=${outgoingMessage.actionType}")
 		kafkaProducerService.sendTilAktivitetskortTopic(
@@ -158,42 +150,41 @@ open class DeltakerProcessor(
 		}
 	}
 
-	private fun getOppfolgingsPeriodeOrThrow(deltaker: TiltakDeltakelse, personIdent: String): Oppfolgingsperiode {
-		return deltaker.modDato?.let { modDato -> oppfolgingsperiodeService.finnOppfolgingsperiode(personIdent, modDato) }
+	private fun getOppfolgingsPeriodeOrThrow(deltaker: TiltakDeltakelse, personIdent: String): FinnOppfolgingResult.FunnetPeriodeResult {
+		val funnetPeriode = deltaker.modDato
+			?.let { modDato -> oppfolgingsperiodeService.finnOppfolgingsperiode(personIdent, modDato) }
 			?: oppfolgingsperiodeService.finnOppfolgingsperiode(personIdent, deltaker.regDato)
 				.also { log.info("arenaId: ${deltaker.tiltakdeltakelseId} Fant ikke oppfolgingsperiode på modDato, bruker fallback til regDato") }
-			?: handleOppfolgingsperiodeNull(deltaker, personIdent, deltaker.modDato ?: deltaker.regDato, deltaker.tiltakdeltakelseId)
+		return when (funnetPeriode) {
+			is FinnOppfolgingResult.FunnetPeriodeResult -> funnetPeriode
+			is FinnOppfolgingResult.IngenPeriodeResult -> handleOppfolgingsperiodeNull(deltaker, personIdent, deltaker.modDato ?: deltaker.regDato, deltaker.tiltakdeltakelseId)
+		}
 	}
 
-	private fun utledEndringsType(oppfolgingsperiode: Oppfolgingsperiode, deltakelseId: DeltakelseId, deltakerStatusKode: String, administrasjonskode: Tiltak.Administrasjonskode): EndringsType {
+	private fun utledEndringsType(
+		periodeMatch: FinnOppfolgingResult.FunnetPeriodeResult,
+		deltakelseId: DeltakelseId,
+		deltakerStatusKode: String,
+		administrasjonskode: Tiltak.Administrasjonskode,
+	): EndringsType {
 		val skalIgnoreres = skalIgnoreres(deltakerStatusKode, administrasjonskode)
-		val oppfolgingsperiodeTilAktivitetskortId = deltakerAktivitetMappingRepository.get(deltakelseId, AktivitetKategori.TILTAKSAKTIVITET)
+		val oppfolgingsperiodeTilAktivitetskortId = aktivitetService.getAllBy(deltakelseId, AktivitetKategori.TILTAKSAKTIVITET)
 		val eksisterendeAktivitetsId = oppfolgingsperiodeTilAktivitetskortId
-			.firstOrNull { it.oppfolgingsperiodeUuid == oppfolgingsperiode.uuid }?.aktivitetId
+			.firstOrNull { it.oppfolgingsPeriode == periodeMatch.oppfolgingsperiode.uuid }?.id
 		return when {
 			// Har tidligere deltakelse på samme oppfolgingsperiode
 			eksisterendeAktivitetsId != null -> EndringsType.OppdaterAktivitet(eksisterendeAktivitetsId, skalIgnoreres)
 			// Har ingen tidligere aktivitetskort
-			oppfolgingsperiodeTilAktivitetskortId.isEmpty() -> EndringsType.NyttAktivitetskort(oppfolgingsperiode, skalIgnoreres)
+			oppfolgingsperiodeTilAktivitetskortId.isEmpty() -> EndringsType.NyttAktivitetskort(periodeMatch.oppfolgingsperiode, skalIgnoreres)
 			// Har tidligere deltakelse men ikke på samme oppfølgingsperiode
-			else -> EndringsType.NyttAktivitetskortByttPeriode(oppfolgingsperiode, skalIgnoreres)
+			else -> {
+				EndringsType.NyttAktivitetskortByttPeriode(periodeMatch.oppfolgingsperiode, skalIgnoreres)
+			}
 		}
 	}
 
-	fun EndringsType.oppdaterMappingMedNyId(deltakelseId: DeltakelseId) {
-		when (this) {
-			is EndringsType.NyttAktivitetskort ->  this.oppfolgingsperiode
-			is EndringsType.NyttAktivitetskortByttPeriode -> this.oppfolgingsperiode
-			is EndringsType.OppdaterAktivitet -> null
-		}?.let {
-			deltakerAktivitetMappingRepository.insert(
-				DeltakerAktivitetMappingDbo(
-				deltakelseId = deltakelseId,
-				aktivitetId = this.aktivitetskortId,
-				aktivitetKategori = AktivitetKategori.TILTAKSAKTIVITET,
-				oppfolgingsperiodeUuid = it.uuid)
-			)
-		}
+	fun syncOppfolgingsperioder(deltakelseId: DeltakelseId, oppfolginsperioder: List<Oppfolgingsperiode>) {
+		aktivitetService.closeClosedPerioder(deltakelseId, AktivitetKategori.TILTAKSAKTIVITET, oppfolginsperioder)
 	}
 }
 

src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/repositories/AktivitetDbo.kt

@@ -11,6 +11,6 @@ data class AktivitetDbo (
 	val data: String,
 	val arenaId: String,
 	val tiltakKode: String,
-	val oppfolgingsperiodeUUID: UUID?,
+	val oppfolgingsperiodeUUID: UUID,
 	val oppfolgingsSluttTidspunkt: ZonedDateTime?
 )

src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/repositories/AktivitetRepository.kt

@@ -1,8 +1,12 @@
 package no.nav.arena_tiltak_aktivitet_acl.repositories
 
+import no.nav.arena_tiltak_aktivitet_acl.clients.oppfolging.AvsluttetOppfolgingsperiode
 import no.nav.arena_tiltak_aktivitet_acl.domain.kafka.aktivitet.AktivitetKategori
+import no.nav.arena_tiltak_aktivitet_acl.domain.kafka.arena.tiltak.DeltakelseId
 import no.nav.arena_tiltak_aktivitet_acl.utils.*
 import org.intellij.lang.annotations.Language
+import org.slf4j.LoggerFactory
+import org.springframework.dao.IncorrectResultSizeDataAccessException
 import org.springframework.jdbc.core.RowMapper
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
@@ -14,7 +18,9 @@ import java.util.*
 open class AktivitetRepository(
 	private val template: NamedParameterJdbcTemplate
 ) {
+	private val log = LoggerFactory.getLogger(javaClass)
 	fun upsert(aktivitet: AktivitetDbo) {
+		@Language("PostgreSQL")
 		val sql = """
 			INSERT INTO aktivitet(id, person_ident, kategori_type, data, arena_id, tiltak_kode, oppfolgingsperiode_uuid, oppfolgingsperiode_slutt_tidspunkt)
 			VALUES (:id,
@@ -26,7 +32,9 @@ open class AktivitetRepository(
 					:oppfolgingsperiode_uuid,
 					:oppfolgingsperiode_slutt_tidspunkt)
 			ON CONFLICT ON CONSTRAINT aktivitet_pkey
-			DO UPDATE SET data = :data::jsonb
+			DO UPDATE SET data = :data::jsonb,
+				oppfolgingsperiode_slutt_tidspunkt = :oppfolgingsperiode_slutt_tidspunkt,
+				oppfolgingsperiode_uuid = :oppfolgingsperiode_uuid
 		""".trimIndent()
 
 		val parameters = MapSqlParameterSource().addValues(
@@ -56,6 +64,55 @@ open class AktivitetRepository(
 
 		return template.query(sql, parameters, rowMapper).firstOrNull()
 	}
+
+	fun getCurrentAktivitetsId(deltakelseId: DeltakelseId, aktivitetKategori: AktivitetKategori): UUID? {
+		@Language("PostgreSQL")
+		val sql = """
+			SELECT DISTINCT ON (arena_id)
+				arena_id,
+			    aktivitet.id,
+			    COALESCE(aktivitet.oppfolgingsperiode_slutt_tidspunkt, TO_TIMESTAMP('9999', 'YYYY')) slutt
+			FROM aktivitet
+			WHERE arena_id = :arenaId
+			ORDER BY arena_id, slutt DESC
+		""".trimIndent()
+		val parameters = mapOf("arenaId" to "${aktivitetKategori.prefix}${deltakelseId.value}")
+		return template.query(sql, parameters) { row, _ -> row.getUUID("id") }
+			.also {
+				if (it.size > 1) {
+					log.error("Got multiple results on currently active aktivitetskort: ${it.size}, deltakerId: ${deltakelseId.value}")
+					throw IncorrectResultSizeDataAccessException(1, it.size)
+				}
+			}
+			.firstOrNull()
+	}
+
+	fun getAllBy(deltakelseId: DeltakelseId, aktivitetKategori: AktivitetKategori): List<AktivitetIdAndOppfolgingsPeriode> {
+		@Language("PostgreSQL")
+		val sql = """
+			SELECT oppfolgingsperiode_uuid as oppfolgingsPeriode, id FROM aktivitet WHERE arena_id = :arenaId
+		""".trimIndent()
+		val params = mapOf("arenaId" to "${aktivitetKategori.prefix}${deltakelseId.value}")
+		return template.query(sql, params) { row, _ ->
+			AktivitetIdAndOppfolgingsPeriode(row.getUUID("id"), row.getUUID("oppfolgingsPeriode")) }
+	}
+
+	fun closeClosedPerioder(deltakelseId: DeltakelseId, aktivitetKategori: AktivitetKategori, oppfolgingsperioder: List<AvsluttetOppfolgingsperiode>) {
+		@Language("PostgreSQL")
+		val sql = """
+			UPDATE aktivitet SET oppfolgingsperiode_slutt_tidspunkt = :slutt
+			WHERE arena_id = :arenaId and oppfolgingsperiode_uuid = :oppfolgingsperiode
+		""".trimIndent()
+		val params = oppfolgingsperioder
+			.map {
+				mapOf(
+					"arenaId" to "${aktivitetKategori.prefix}${deltakelseId.value}",
+					"slutt" to it.sluttDato.toOffsetDateTime(),
+					"oppfolgingsperiode" to it.uuid
+				)
+			}.toTypedArray()
+		template.batchUpdate(sql, params)
+	}
 }
 
 fun ResultSet.toAktivitetDbo() =
@@ -66,6 +123,11 @@ fun ResultSet.toAktivitetDbo() =
 		data = this.getString("data"),
 		arenaId = this.getString("arena_id"),
 		tiltakKode = this.getString("tiltak_kode"),
-		oppfolgingsperiodeUUID = this.getNullableUUID("oppfolgingsperiode_uuid"),
+		oppfolgingsperiodeUUID = this.getUUID("oppfolgingsperiode_uuid"),
 		oppfolgingsSluttTidspunkt = this.getNullableZonedDateTime("oppfolgingsperiode_slutt_tidspunkt"),
 	)
+
+data class AktivitetIdAndOppfolgingsPeriode(
+	val id: UUID,
+	val oppfolgingsPeriode: UUID
+)