TFP-5615 legg om til Sigrun PGI for Folketrygden (#2467)

* Tfeature/TFP-5615-bruk-pgiFP-5615 legg om til Sigrun PGI for Folketrygden

* TFP-5615 ta med kildeskatt lønn

* Forenkle oppsett Sigrun

* Restanser

* Felles 709 fra master

* Sigrun skal håndtere PGIF008

Author: jolarsen

domenetjenester/iay/src/main/java/no/nav/foreldrepenger/abakus/registerdata/IAYRegisterInnhentingTjeneste.java

@@ -96,8 +96,9 @@ public IAYRegisterInnhentingTjeneste(InntektArbeidYtelseTjeneste inntektArbeidYt
         LOG.info("Henter lignet inntekt for sak=[{}, {}] med behandling='{}'", kobling.getSaksnummer(), kobling.getYtelseType(),
             kobling.getKoblingReferanse());
 
-        var map = sigrunTjeneste.beregnetSkatt(kobling.getAktørId(), new FnrSupplier(kobling.getAktørId())::tilPersonIdent,
-            kobling.getOpplysningsperiodeSkattegrunnlag());
+        var personIdent = getFnrFraAktørId(kobling.getAktørId());
+
+        var map = sigrunTjeneste.hentPensjonsgivende(personIdent, kobling.getOpplysningsperiodeSkattegrunnlag());
         var aktørInntektBuilder = inntektArbeidYtelseAggregatBuilder.getAktørInntektBuilder(kobling.getAktørId());
 
         var inntektBuilder = aktørInntektBuilder.getInntektBuilder(InntektskildeType.SIGRUN, null);

domenetjenester/iay/src/main/java/no/nav/foreldrepenger/abakus/registerdata/inntekt/sigrun/SigrunTilInternMapper.java

@@ -1,10 +1,16 @@
 package no.nav.foreldrepenger.abakus.registerdata.inntekt.sigrun;
 
+import static java.time.temporal.ChronoUnit.YEARS;
+
 import java.math.BigDecimal;
+import java.time.Month;
+import java.time.MonthDay;
 import java.time.Year;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
 import java.util.Map;
-import java.util.Objects;
-import java.util.function.Supplier;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 import org.slf4j.Logger;
@@ -14,110 +20,78 @@
 import jakarta.inject.Inject;
 import no.nav.abakus.iaygrunnlag.kodeverk.InntektspostType;
 import no.nav.foreldrepenger.abakus.felles.jpa.IntervallEntitet;
-import no.nav.foreldrepenger.abakus.registerdata.inntekt.sigrun.klient.SigrunConsumer;
-import no.nav.foreldrepenger.abakus.registerdata.inntekt.sigrun.klient.SigrunResponse;
-import no.nav.foreldrepenger.abakus.registerdata.inntekt.sigrun.klient.pgifolketrygden.SigrunPgiFolketrygdenMapper;
-import no.nav.foreldrepenger.abakus.registerdata.inntekt.sigrun.klient.summertskattegrunnlag.SigrunSummertSkattegrunnlagResponse;
-import no.nav.foreldrepenger.abakus.typer.AktørId;
+import no.nav.foreldrepenger.abakus.registerdata.inntekt.sigrun.klient.PgiFolketrygdenResponse;
+import no.nav.foreldrepenger.abakus.registerdata.inntekt.sigrun.klient.SigrunPgiFolketrygdenMapper;
+import no.nav.foreldrepenger.abakus.registerdata.inntekt.sigrun.klient.SigrunRestClient;
 import no.nav.foreldrepenger.abakus.typer.PersonIdent;
 
 
 @ApplicationScoped
 public class SigrunTjeneste {
     private static final Logger LOG = LoggerFactory.getLogger(SigrunTjeneste.class);
 
-    private static final boolean SAMMENLIGN_PGI = true;
+    private static final MonthDay TIDLIGSTE_SJEKK_FJOR = MonthDay.of(Month.MAY, 1);
 
-    private SigrunConsumer sigrunConsumer;
+    private static final Year FØRSTE_PGI = Year.of(2017);
+    private SigrunRestClient sigrunConsumer;
 
     SigrunTjeneste() {
         //CDI
     }
 
     @Inject
-    public SigrunTjeneste(SigrunConsumer sigrunConsumer) {
+    public SigrunTjeneste(SigrunRestClient sigrunConsumer) {
         this.sigrunConsumer = sigrunConsumer;
     }
 
 
-    public Map<IntervallEntitet, Map<InntektspostType, BigDecimal>> hentPensjonsgivende(Supplier<PersonIdent> fnrSupplier, IntervallEntitet opplysningsperiodeSkattegrunnlag) {
-        var fnr = fnrSupplier.get();
-        if (fnr == null || fnr.getIdent() == null) {
-            LOG.info("SIGRUN PGI: fant ikke fnr for aktørid");
-            return Map.of();
-        }
-        var svarene = sigrunConsumer.pensjonsgivendeInntektForFolketrygden(fnr.getIdent(), opplysningsperiodeSkattegrunnlag);
+    public Map<IntervallEntitet, Map<InntektspostType, BigDecimal>> hentPensjonsgivende(PersonIdent fnr, IntervallEntitet opplysningsperiodeSkattegrunnlag) {
+        var svarene = pensjonsgivendeInntektForFolketrygden(fnr.getIdent(), opplysningsperiodeSkattegrunnlag);
         return SigrunPgiFolketrygdenMapper.mapFraPgiResponseTilIntern(svarene).entrySet().stream()
             .filter(e -> !e.getValue().isEmpty())
             .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
     }
 
-    public Map<IntervallEntitet, Map<InntektspostType, BigDecimal>> beregnetSkatt(AktørId aktørId, Supplier<PersonIdent> fnrSupplier, IntervallEntitet opplysningsperiodeSkattegrunnlag) {
+    private List<PgiFolketrygdenResponse> pensjonsgivendeInntektForFolketrygden(String fnr, IntervallEntitet opplysningsperiode) {
+        var senesteÅr = utledSenesteÅr(opplysningsperiode);
+        List<PgiFolketrygdenResponse> svarene = new ArrayList<>();
+        var svarSenesteÅr = svarForSenesteÅr(fnr, senesteÅr);
+        svarSenesteÅr.ifPresent(svarene::add);
+        utledTidligereÅr(opplysningsperiode, senesteÅr, svarSenesteÅr.isPresent())
+            .forEach(år -> sigrunConsumer.hentPensjonsgivendeInntektForFolketrygden(fnr, år).ifPresent(svarene::add));
+        return svarene;
+    }
 
-        var justertOpplysningsperiode = justerOpplysningsperiodeNårSisteÅrIkkeErFerdiglignet(Long.valueOf(aktørId.getId()), opplysningsperiodeSkattegrunnlag);
-        SigrunResponse beregnetskatt = sigrunConsumer.beregnetskatt(Long.valueOf(aktørId.getId()), justertOpplysningsperiode);
-        SigrunSummertSkattegrunnlagResponse summertSkattegrunnlag = sigrunConsumer.summertSkattegrunnlag(Long.valueOf(aktørId.getId()),
-            opplysningsperiodeSkattegrunnlag);
-        var resultat = SigrunTilInternMapper.mapFraSigrunTilIntern(beregnetskatt.beregnetSkatt(), summertSkattegrunnlag.summertskattegrunnlagMap());
-        if (SAMMENLIGN_PGI) {
-            sammenlignPGI(fnrSupplier, justertOpplysningsperiode, resultat);
-        }
-        return resultat;
+    private Year utledSenesteÅr(IntervallEntitet opplysningsperiode) {
+        var ifjor = Year.now().minusYears(1);
+        var oppgitt = opplysningsperiode != null ? Year.from(opplysningsperiode.getTomDato()) : ifjor;
+        return oppgitt.isAfter(ifjor) ? ifjor : oppgitt;
     }
 
-    private void sammenlignPGI(Supplier<PersonIdent> fnrSupplier, IntervallEntitet opplysningsperiode,
-                               Map<IntervallEntitet, Map<InntektspostType, BigDecimal>> bs) {
+    public Optional<PgiFolketrygdenResponse> svarForSenesteÅr(String fnr, Year senesteÅr) {
+        if (Year.now().minusYears(1).equals(senesteÅr) && MonthDay.now().isBefore(TIDLIGSTE_SJEKK_FJOR)) {
+            return Optional.empty();
+        }
         try {
-            var nettoBs = bs.entrySet().stream().filter(e -> !e.getValue().isEmpty()).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-            var nettoPgi = hentPensjonsgivende(fnrSupplier, opplysningsperiode);
-            if (nettoBs.isEmpty() && nettoPgi.isEmpty()) {
-                LOG.info("SIGRUN PGI: sammenlignet OK tomme svar fra begge");
-            } else if (!nettoPgi.values().isEmpty() && nettoPgi.values().stream().anyMatch(v -> !v.values().isEmpty())) {
-                if (sammenlignMaps(nettoBs, nettoPgi)) {
-                    LOG.info("SIGRUN PGI: sammenlignet OK");
-                } else {
-                    LOG.info("SIGRUN PGI: sammenlignet DIFF BS/SSG {} PGI {}", bs, nettoPgi);
-                }
-            } else if (!nettoBs.values().isEmpty() && nettoBs.values().stream().anyMatch(v -> !v.values().isEmpty())) {
-                LOG.info("SIGRUN PGI: tomt svar fra PGI BS//SG {}", bs);
-            } else {
-                LOG.info("SIGRUN PGI: tomme svar fra BS//SG {}", bs);
-            }
+            return sigrunConsumer.hentPensjonsgivendeInntektForFolketrygden(fnr, senesteÅr);
         } catch (Exception e) {
-            LOG.info("SIGRUN PGI: noe gikk veldig galt", e);
+            return Optional.empty();
         }
     }
 
-    private static boolean sammenlignMaps(Map<IntervallEntitet, Map<InntektspostType, BigDecimal>> bs, Map<IntervallEntitet, Map<InntektspostType, BigDecimal>> pgi) {
-        return Objects.equals(bs.keySet(), pgi.keySet()) && pgi.entrySet().stream().allMatch(e -> sammenlignSubMaps(bs.get(e.getKey()), e.getValue()));
-    }
-
-    private static boolean sammenlignSubMaps(Map<InntektspostType, BigDecimal> bs, Map<InntektspostType, BigDecimal> pgi) {
-        return bs != null && Objects.equals(bs.keySet(), pgi.keySet()) && pgi.entrySet().stream().allMatch(e -> sammenlignSubMapVerdier(bs.get(e.getKey()), e.getValue()));
-    }
-
-    private static boolean sammenlignSubMapVerdier(BigDecimal bs, BigDecimal pgi) {
-        return Objects.equals(bs, pgi) || (bs != null && pgi.compareTo(bs) == 0);
-    }
-
-    IntervallEntitet justerOpplysningsperiodeNårSisteÅrIkkeErFerdiglignet(Long aktørId, IntervallEntitet opplysningsperiode) {
-        if (opplysningsperiode == null){
-            return null; //fpsak spør unten å oppgi periode
+    private List<Year> utledTidligereÅr(IntervallEntitet opplysningsperiode, Year senesteÅr, boolean harDataSenesteÅr) {
+        long periodeLengde = opplysningsperiode != null ? YEARS.between(opplysningsperiode.getFomDato(), opplysningsperiode.getTomDato()) : 2L;
+        var tidligsteÅr = opplysningsperiode != null ? Year.from(opplysningsperiode.getFomDato()) : senesteÅr.minusYears(2);
+        var fraTidligsteÅr = harDataSenesteÅr || periodeLengde > 2L ? tidligsteÅr : tidligsteÅr.minusYears(1);
+        if (fraTidligsteÅr.isBefore(FØRSTE_PGI)) {
+            fraTidligsteÅr = FØRSTE_PGI;
         }
-        // justerer slik at vi henter ett å eldre data når siste år som etterspørs ikke er ferdiglignet enda
-        int fomÅr = opplysningsperiode.getFomDato().getYear();
-        int tomÅr = opplysningsperiode.getTomDato().getYear();
-        Year iFjor = Year.now().minusYears(1);
-        LOG.info("Opprinnelig opplysningsperiode er fom {} tom {}", fomÅr, tomÅr);
-        if (opplysningsperiode.getTomDato().getYear() == iFjor.getValue()) {
-            boolean fjoråretFerdiglignet = sigrunConsumer.erÅretFerdiglignet(aktørId, iFjor);
-            LOG.info("Ferdiglignet {}", fjoråretFerdiglignet);
-            if (!fjoråretFerdiglignet && tomÅr - fomÅr < 3) { //dataminimering, ikke behov for data ut over 3 hele år før første stp
-                LOG.info("Utvider opplysningsperioden med ett år pga ikke-ferdiglignet år");
-                return IntervallEntitet.fraOgMedTilOgMed(opplysningsperiode.getFomDato().minusYears(1), opplysningsperiode.getTomDato());
-            }
+        List<Year> årene = new ArrayList<>();
+        while (fraTidligsteÅr.isBefore(senesteÅr)) {
+            årene.add(fraTidligsteÅr);
+            fraTidligsteÅr = fraTidligsteÅr.plusYears(1);
         }
-        return opplysningsperiode;
+        return årene.stream().sorted(Comparator.reverseOrder()).toList();
     }
 
 }

domenetjenester/iay/src/main/java/no/nav/foreldrepenger/abakus/registerdata/inntekt/sigrun/SigrunTjeneste.java

@@ -1,7 +1,8 @@
-package no.nav.foreldrepenger.abakus.registerdata.inntekt.sigrun.klient.pgifolketrygden;
+package no.nav.foreldrepenger.abakus.registerdata.inntekt.sigrun.klient;
 
 import java.time.LocalDate;
 import java.util.List;
+import java.util.Optional;
 
 public record PgiFolketrygdenResponse(String norskPersonidentifikator, Integer inntektsaar, List<Pgi> pensjonsgivendeInntekt) {
     public record Pgi(Skatteordning skatteordning, LocalDate datoForFastsetting, Long pensjonsgivendeInntektAvLoennsinntekt,
@@ -12,11 +13,8 @@ public enum Skatteordning {
         FASTLAND, SVALBARD, KILDESKATT_PAA_LOENN
     }
 
-    // Mens vi venter på avklaring rundt kildeskatt
-    public List<Pgi> pgiSomSikkertKanBrukes() {
-        return pensjonsgivendeInntekt().stream()
-            .filter(p -> !Skatteordning.KILDESKATT_PAA_LOENN.equals(p.skatteordning()))
-            .toList();
+    public List<Pgi> safePensjonsgivendeInntekt() {
+        return Optional.ofNullable(pensjonsgivendeInntekt()).orElse(List.of());
     }
 
     @Override