Skip to content

Commit

Permalink
🚀 Fjerne translation tabell (#73)
Browse files Browse the repository at this point in the history 
* Fjerne translation tabell

* Drop translation table

* Fix test

* Use idmapping client in tests instead of dao

* Fjern bruk av deltaker-mapping-tabell

* Fix arenaid in test

* Foreløpig ignorerete tiltak skal gi ut mapping

* Set oppfølgingsperiode avsluttet når det byttes periode på aktivitet

* rename flyway script

* Split flyway script

* Remove unused imports

* Slett 3 script som ikke skal med i denne mergen

---------

Co-authored-by: sigurdgroneng <[email protected]>
  • Loading branch information
@holymaloney @tu55eladd
holymaloney and tu55eladd authored Oct 24, 2023
1 parent 6a90987 commit 4262532
Show file tree
Hide file tree
Showing 23 changed files with 233 additions and 340 deletions.
6 changes: 6 additions & 0 deletions src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/clients/oppfolging/Oppfolgingsperiode.kt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,3 +15,9 @@ data class Oppfolgingsperiode (
return startetIPeriode && foerSluttDato
}
}

data class AvsluttetOppfolgingsperiode (
val uuid: UUID,
val startDato: ZonedDateTime,
val sluttDato: ZonedDateTime
)
4 changes: 2 additions & 2 deletions src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/domain/db/ArenaDataUpsertInput.kt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand Down
7 changes: 4 additions & 3 deletions ...main/kotlin/no/nav/arena_tiltak_aktivitet_acl/domain/kafka/aktivitet/AktivitetKategori.kt
View file
Original file line number Diff line number Diff line change
@@ -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")
}
2 changes: 1 addition & 1 deletion .../kotlin/no/nav/arena_tiltak_aktivitet_acl/domain/kafka/aktivitet/AktivitetskortHeaders.kt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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?,
)
{
Expand Down
81 changes: 36 additions & 45 deletions src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/processors/DeltakerProcessor.kt
View file
Original file line number Diff line number Diff line change
@@ -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
Expand All @@ -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
Expand All @@ -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 {
Expand Down Expand Up @@ -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,
Expand All @@ -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(
Expand Down Expand Up @@ -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)
}
}

Expand Down
2 changes: 1 addition & 1 deletion src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/repositories/AktivitetDbo.kt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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?
)
66 changes: 64 additions & 2 deletions src/main/kotlin/no/nav/arena_tiltak_aktivitet_acl/repositories/AktivitetRepository.kt
View file
Original file line number Diff line number Diff line change
@@ -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
Expand All @@ -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,
Expand All @@ -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(
Expand Down Expand Up @@ -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() =
Expand All @@ -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
)
78 changes: 0 additions & 78 deletions ...in/no/nav/arena_tiltak_aktivitet_acl/repositories/ArenaIdTilAktivitetskortIdRepository.kt
View file

This file was deleted.

Loading

0 comments on commit 4262532

Please sign in to comment.