aziendasanitaria-utils 1.2.71 → 1.2.72

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=14.0.0"
   },
-  "version": "1.2.71",
+  "version": "1.2.72",
   "repository": "deduzzo/aziendasanitaria-utils",
   "description": "Un utility per gestire i flussi sanitari Siciliani e non solo..",
   "main": "index.js",

package/src/narTsServices/Nar2.js

@@ -3,7 +3,8 @@ import {Assistito, DATI} from "../classi/Assistito.js";
 import moment from "moment";
 import _ from "lodash";
 import CryptHelper from "../CryptHelper.js";
-import {STATO_TS, snapshotDaSogei, classificaStatoTs, ASP_MESSINA} from "./statoAssistitoTs.js";
+import {Ts} from "./Ts.js";
+import {STATO_TS, snapshotDaSogei, classificaStatoTs, ASP_MESSINA, estraiCodiceAsl} from "./statoAssistitoTs.js";
 
 export class Nar2 {
     static LOGIN_URL = "https://nar2.regione.sicilia.it/services/index.php/api/login";
@@ -193,6 +194,10 @@ export class Nar2 {
         this._cryptData = (crtyptData.hasOwnProperty("KEY") && crtyptData.hasOwnProperty("IV"))
             ? crtyptData
             : null;
+        // Conservato per il fallback legacy verso il portale TS (scraping) quando
+        // l'endpoint Sogei è irraggiungibile: il Ts viene creato lazy da #tsScraper().
+        this._impostazioni = impostazioniServiziTerzi;
+        this._ts = null;
     }
 
     /**
@@ -695,10 +700,11 @@ export class Nar2 {
 
         // 3) Scelta medico corrente (per revoca_scelta_precedente)
         // La scelta attiva si trova in storico_medici[*] con pm_fstato="A" e pm_dt_disable=null.
-        // Per una "variazione" il server richiede SEMPRE i dati di revoca della scelta precedente
-        // (errore 400 "Dati di revoca della scelta precedente mancanti o non validi"); se non c'è
-        // una scelta strettamente attiva (es. dopo una revoca standalone) si usa il rapporto più
-        // recente in storico (pm_id più alto). Per una vera prima iscrizione passare forzaSenzaRevoca:true.
+        // Il server richiede SEMPRE il blocco revoca_scelta_precedente (errore 400/500 se
+        // assente), ANCHE in prima iscrizione: se non c'è un rapporto precedente revoca_id = ""
+        // (come il portale). Se non c'è una scelta strettamente attiva (es. dopo una revoca
+        // standalone) si usa il rapporto più recente in storico (pm_id più alto).
+        // forzaSenzaRevoca:true omette del tutto il blocco (sconsigliato: il server lo rifiuta).
         let revocaPrecedente = null;
         if (!forzaSenzaRevoca) {
             const storico = Array.isArray(fullData.storico_medici) ? fullData.storico_medici : [];
@@ -707,15 +713,19 @@ export class Nar2 {
                 sceltaPrecedente = storico.slice().sort((a, b) => (parseInt(b?.pm_id, 10) || 0) - (parseInt(a?.pm_id, 10) || 0))[0];
             }
             const pmIdCorrente = sceltaPrecedente?.pm_id ?? null;
-            if (pmIdCorrente) {
-                revocaPrecedente = {
-                    pm_dt_disable: dataRevoca,
-                    dm_dt_ins_revoca: dataInsRevoca,
-                    dm_motivo_revoca: motivoRevoca, // popolato sotto se null
-                    dm_tipoop_revoca: tipoOperazioneRevoca,
-                    revoca_id: typeof pmIdCorrente === "string" ? parseInt(pmIdCorrente, 10) : pmIdCorrente
-                };
-            }
+            // Il server VUOLE SEMPRE il blocco revoca_scelta_precedente, anche in PRIMA
+            // ISCRIZIONE (nessun medico precedente): in quel caso revoca_id = "" (stringa
+            // vuota), esattamente come fa il portale. Ometterlo del tutto → 500 "Server Error"
+            // (verificato confrontando la POST reale del portale con la nostra).
+            revocaPrecedente = {
+                pm_dt_disable: dataRevoca,
+                dm_dt_ins_revoca: dataInsRevoca,
+                dm_motivo_revoca: motivoRevoca, // popolato sotto se null (default A04)
+                dm_tipoop_revoca: tipoOperazioneRevoca,
+                revoca_id: pmIdCorrente != null
+                    ? (typeof pmIdCorrente === "string" ? parseInt(pmIdCorrente, 10) : pmIdCorrente)
+                    : ""
+            };
         }
 
         // 4) Situazione assistenziale + motivo + tipo operazione (dal catalogo)
@@ -759,11 +769,19 @@ export class Nar2 {
             return {ok: false, dryRun, payload: null, response: null, error: "Impossibile determinare il motivo della scelta"};
         }
 
-        // Allinea il motivo revoca se non specificato
+        // Motivo della revoca della scelta precedente: il portale usa A04 "Cambio medico"
+        // (anche in prima iscrizione, con revoca_id vuoto) — NON il motivo della nuova scelta.
+        // L'override esplicito (config.motivoRevoca, es. A17 in deroga) resta rispettato.
         if (revocaPrecedente && !revocaPrecedente.dm_motivo_revoca) {
-            revocaPrecedente.dm_motivo_revoca = motivoFinale;
+            revocaPrecedente.dm_motivo_revoca = Nar2.MOTIVO_CAMBIO_MEDICO;
         }
 
+        // Pediatri: "data fine proroga" (assistenza fino a 16 anni). Il portale la imposta a
+        // data di nascita + 16 anni; se non fornita la deriviamo (per gli MMG resta null).
+        const fineProrogaPed = tipoMedico === Nar2.PEDIATRA
+            ? (dataFineProrogaPed ?? moment(fullData.pz_dt_nas, "YYYY-MM-DD HH:mm:ss").add(16, "years").format("YYYY-MM-DD"))
+            : null;
+
         // 5) Payload
         const payload = {
             data: {
@@ -781,7 +799,7 @@ export class Nar2 {
                 dm_ambito_scelta: ambitoScelta?.toString(),
                 dm_motivo_scelta: motivoFinale,
                 dm_tipoop_scelta: tipoOpFinale,
-                dm_dt_fine_proroga_ped: tipoMedico === Nar2.PEDIATRA ? dataFineProrogaPed : null,
+                dm_dt_fine_proroga_ped: fineProrogaPed,
                 dm_motivo_pror_scad_ped: tipoMedico === Nar2.PEDIATRA ? motivoProrogaPed : null
             }
         };
@@ -2839,6 +2857,174 @@ export class Nar2 {
         return {ok, unico, documenti: risultati};
     }
 
+    // Crea lazy lo scraper del portale TS (legacy) dalla stessa ImpostazioniServiziTerzi.
+    // Usato come fallback quando l'endpoint NAR2/Sogei è irraggiungibile.
+    #tsScraper() {
+        if (!this._ts) this._ts = new Ts(this._impostazioni);
+        return this._ts;
+    }
+
+    // MAPPER UNICO p801 → Assistito (estratto dal ramo di successo di
+    // getDatiAssistitoFromCfSuSogeiNew, logica INVARIATA). Usato sia dalla risposta Sogei
+    // sia dal fallback legacy, così la mappatura è identica per entrambe le fonti.
+    #popolaAssistitoDaP801(assistito, data, cf, envelope) {
+        const nullArray = (d) => (Array.isArray(d) && d.length === 0 ? "" : d);
+        const deceduto = data?.p801descrizioneCodiceTipoAssistito?.toLowerCase().includes("deceduto") ?? false;
+        const asp = nullArray(data.p801codiceRegioneResidenzaAsl) + " - " +
+            nullArray(data.p801descrizioneRegioneResidenzaAsl) + " " +
+            nullArray(data.p801codiceAslResidenzaAsl) + " - " +
+            nullArray(data.p801descrizioneAslResidenzaAsl).trim();
+
+        assistito.setTs(DATI.CF, cf.toUpperCase().trim());
+        assistito.setTs(DATI.CF_NORMALIZZATO, nullArray(data.p801codiceFiscale));
+        assistito.setTs(DATI.COGNOME, nullArray(data.p801cognome));
+        assistito.setTs(DATI.NOME, nullArray(data.p801nome));
+        assistito.setTs(DATI.SESSO, nullArray(data.p801sesso));
+        assistito.setTs(DATI.DATA_NASCITA, nullArray(data.p801dataNascita));
+        assistito.setTs(DATI.COMUNE_NASCITA, nullArray(data.p801comuneNascita));
+        assistito.setTs(DATI.COD_COMUNE_NASCITA, nullArray(data.p801codiceComuneNascita));
+        assistito.setTs(DATI.COD_ISTAT_COMUNE_NASCITA, nullArray(data.p801codiceistatiComuneNascita));
+        assistito.setTs(DATI.INDIRIZZO_RESIDENZA, nullArray(data.p801recapitoTessera));
+        assistito.setTs(DATI.COD_COMUNE_RESIDENZA, nullArray(data.p801codiceComuneResidenza));
+        assistito.setTs(DATI.COD_ISTAT_COMUNE_RESIDENZA, nullArray(data.p801codiceistatiComuneResidenza));
+        assistito.setTs(DATI.ASP, asp !== " -   - " ? asp : "");
+        assistito.setTs(DATI.MMG_CF, nullArray(data.p801codiceFiscaleMedico));
+        assistito.setTs(DATI.MMG_COGNOME, nullArray(data.p801cognomeMedico));
+        assistito.setTs(DATI.MMG_NOME, nullArray(data.p801nomeMedico));
+        assistito.setTs(DATI.MMG_DATA_SCELTA, nullArray(data.p801dataAssociazioneMedico));
+        assistito.setTs(DATI.SSN_TIPO_ASSISTITO, nullArray(data.p801descrizioneCodiceTipoAssistito));
+        assistito.setTs(DATI.SSN_INIZIO_ASSISTENZA, nullArray(data.p801dataInizioValidita));
+        assistito.setTs(DATI.SSN_FINE_ASSISTENZA, data.p801dataFineValidita === "31/12/9999" ? "illimitata" : nullArray(data.p801dataFineValidita));
+        assistito.setTs(DATI.SSN_MOTIVAZIONE_FINE_ASSISTENZA, data.p801dataFineValidita !== "31/12/9999" ? nullArray(data.p801motivazioneFineValidita) : null);
+        assistito.setTs(DATI.SSN_NUMERO_TESSERA, nullArray(data.p801numeroTessera));
+        assistito.setTs(DATI.DATA_DECESSO, deceduto ? nullArray(data.p801dataDecesso) : null);
+        assistito.okTs = true;
+        assistito.fullDataTs = envelope;
+    }
+
+    // FALLBACK LEGACY: quando Sogei è irraggiungibile, ricostruisce i campi p801* dallo
+    // scraping del portale TS (getDatiAnagraficiAssistito + getIndirizzoUltimaTessera) e
+    // li passa al MAPPER esistente (#popolaAssistitoDaP801), restituendo la STESSA shape
+    // { ok, fullData:{status,data:{p801*},_fonte:"legacy-ts"}, data:Assistito }.
+    // Ritorna null se anche lo scraping è irraggiungibile (→ il chiamante torna ok:false).
+    async #fallbackLegacyTsToP801(cf, assistito) {
+        const cfUp = cf?.toUpperCase()?.trim();
+        if (!cfUp || !this._impostazioni) return null;
+        const ts = this.#tsScraper();
+
+        // 1) Anagrafica + dati assistenza (pagina "Visualizza Assistito")
+        const anagRes = await ts.getDatiAnagraficiAssistito({codiceFiscale: cfUp});
+        if (anagRes?.error) {
+            const msg = (anagRes.message || "").toString();
+            // "non trovato/censito" = esito VALIDO (non un guasto): ok:true + okTs:false,
+            // così resta la distinzione esiste=false (verificaAssistitoTsNar2).
+            if (/non\s+trovat|nessun|non\s+censit|non\s+esiste/i.test(msg)) {
+                assistito.okTs = false;
+                assistito.erroreTs = msg || "Assistito non presente sul Sistema TS (portale)";
+                return {ok: true, fullData: {status: false, _fonte: "legacy-ts"}, data: assistito};
+            }
+            return null; // login/rete: scraping irraggiungibile → ok:false a monte
+        }
+        const a = anagRes.data || {};
+        const s = (x) => (x == null ? "" : String(x).trim());
+
+        // 2) Recapito + numero tessera (best-effort: non blocca se assente)
+        let indirizzo = "", numeroTessera = "";
+        try {
+            const tessRes = await ts.getIndirizzoUltimaTessera({codiceFiscale: cfUp});
+            if (!tessRes?.error && tessRes.data) {
+                indirizzo = s(tessRes.data.indirizzo);
+                numeroTessera = s(tessRes.data.numero_tessera);
+            }
+        } catch { /* recapito non disponibile */ }
+
+        // 3) Parsing dei dati grezzi in campi p801
+        // CF medico dal campo "medico" = "COGNOME NOME - CFMEDICO"
+        const medicoStr = s(a.medico);
+        const mCf = medicoStr.match(/\b([A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z])\b/i);
+        const cfMedico = mCf ? mCf[1].toUpperCase() : "";
+        const cognomeMedico = medicoStr ? medicoStr.replace(/\s*-\s*[A-Z0-9]{16}\s*$/i, "").trim() : "";
+        // codice tipo assistito da "1 - assistito in ASL di residenza" (NB: inaffidabile per neonati)
+        const tipoDesc = s(a.tipo_assistito);
+        const mTipo = tipoDesc.match(/^\s*([A-Z0-9]+)\s*-/i);
+        const codTipo = mTipo ? mTipo[1] : "";
+        // ASL/regione da "190 - Sicilia 205 - ASP MESSINA"
+        const aslStr = s(a.asl) || s(a.campi?.["ASL"]);
+        const fonteAtStr = s(a.campi?.["Fonte AT"]) || aslStr;
+        const codAsl = estraiCodiceAsl(aslStr) || "";
+        const codAslAT = estraiCodiceAsl(fonteAtStr) || "";
+        const mReg = aslStr.match(/(\d{3})\s*-\s*([^0-9]+?)\s+(\d{3})\s*-\s*(.+)$/);
+        const codReg = mReg ? mReg[1] : "";
+        const descReg = mReg ? mReg[2].trim() : "";
+        const descAsl = mReg ? mReg[4].trim() : "";
+        // data fine validità: "Illimitata"/vuoto → sentinella 31/12/9999 (come Sogei)
+        const fineRaw = s(a.data_fine_validita);
+        const dataFineValidita = (fineRaw === "" || /illimitat/i.test(fineRaw)) ? "31/12/9999" : fineRaw;
+        // comune di nascita: catastale (Belfiore) dal CF stesso (es. ...F158... → "F158")
+        const belfiore = /^[A-Z0-9]{16}$/i.test(cfUp) ? cfUp.substring(11, 15).toUpperCase() : "";
+
+        // 4) Reverse-lookup del comune di RESIDENZA dal recapito (CAP, poi nome) → id NAR2 +
+        // catastale. Best-effort: usa l'endpoint comuni NAR2, disponibile solo se NAR2 è
+        // raggiungibile (serve all'inserimento nuovo assistito, che richiede comunque NAR2;
+        // il cambio medico usa solo il recapito testuale, già disponibile).
+        let comuneResidenzaId = "", catastaleResidenza = "";
+        const mRecap = indirizzo.match(/(\d{5})\s+(.+?)\s+\(([A-Za-z]{2})\)\s*$/);
+        const capRes = mRecap ? mRecap[1] : (indirizzo.match(/\b(\d{5})\b/)?.[1] ?? "");
+        const nomeRes = mRecap ? mRecap[2].trim() : "";
+        const prendiComune = (cm) => {
+            if (cm?.ok && cm.comune?.id != null) {
+                comuneResidenzaId = cm.comune.id.toString();
+                catastaleResidenza = (cm.comune.catastale ?? "").toString();
+                return true;
+            }
+            return false;
+        };
+        try {
+            const cm = capRes ? await this.getComuneNar2({cap: capRes}) : null;
+            if (!prendiComune(cm) && nomeRes) prendiComune(await this.getComuneNar2({nome: nomeRes}));
+        } catch { /* lookup comune non disponibile (NAR2 irraggiungibile) */ }
+
+        // 5) Ricostruzione p801* (stessi nomi consumati dal mapper e dai chiamanti)
+        const p801 = {
+            p801codiceFiscale: s(a.codice_fiscale) || cfUp,
+            p801cognome: s(a.cognome),
+            p801nome: s(a.nome),
+            p801sesso: s(a.sesso),
+            p801dataNascita: s(a.data_nascita),
+            p801comuneNascita: s(a.comune_nascita),
+            p801codiceComuneNascita: belfiore,
+            p801codiceistatiComuneNascita: "",
+            p801codiceistatiComuneId: "",
+            p801recapitoTessera: indirizzo,
+            p801codiceComuneResidenza: catastaleResidenza,
+            p801codiceistatiComuneResidenza: "",
+            p801ComuneResidenzaId: comuneResidenzaId,
+            p801codiceFiscaleMedico: cfMedico,
+            p801cognomeMedico: cognomeMedico,
+            p801nomeMedico: "",
+            p801dataAssociazioneMedico: s(a.data_associazione_medico),
+            p801descrizioneCodiceTipoAssistito: tipoDesc,
+            p801codiceTipoAssistito: codTipo,
+            p801dataInizioValidita: s(a.data_inizio_validita),
+            p801dataFineValidita: dataFineValidita,
+            p801motivazioneFineValidita: "",
+            p801numeroTessera: numeroTessera,
+            p801dataDecesso: "",
+            p801codiceAslAssistenza: codAsl,
+            p801codiceRegioneAssistenza: codReg,
+            p801codiceAslResidenzaAsl: codAsl,
+            p801codiceAslResidenzaAT: codAslAT,
+            p801codiceRegioneResidenzaAsl: codReg,
+            p801descrizioneRegioneResidenzaAsl: descReg,
+            p801descrizioneAslResidenzaAsl: descAsl,
+            p801listaMessaggi: [],
+        };
+        const envelope = {status: "true", data: p801, listaMessaggi: {}, _fonte: "legacy-ts"};
+        this.#popolaAssistitoDaP801(assistito, p801, cfUp, envelope);
+        assistito.erroreTs = null;
+        return {ok: true, fullData: envelope, data: assistito};
+    }
+
     async getDatiAssistitoFromCfSuSogeiNew(cf, assistito = null, fallback = false) {
         let ok = false;
         let risultato = null; // valore di ritorno del ramo di successo (fix: prima non veniva mai ritornato)
@@ -2891,38 +3077,9 @@ export class Nar2 {
                     };
                 } else {
                     ok = true;
-                    const deceduto = out.data.data?.p801descrizioneCodiceTipoAssistito?.toLowerCase().includes("deceduto") ?? false;
-                    const asp = nullArray(out.data.data.p801codiceRegioneResidenzaAsl) + " - " +
-                        nullArray(out.data.data.p801descrizioneRegioneResidenzaAsl) + " " +
-                        nullArray(out.data.data.p801codiceAslResidenzaAsl) + " - " +
-                        nullArray(out.data.data.p801descrizioneAslResidenzaAsl).trim();
-
-                    // Popoliamo i dati in fromTs usando i setter
-                    assistito.setTs(DATI.CF, cf.toUpperCase().trim());
-                    assistito.setTs(DATI.CF_NORMALIZZATO, nullArray(out.data.data.p801codiceFiscale));
-                    assistito.setTs(DATI.COGNOME, nullArray(out.data.data.p801cognome));
-                    assistito.setTs(DATI.NOME, nullArray(out.data.data.p801nome));
-                    assistito.setTs(DATI.SESSO, nullArray(out.data.data.p801sesso));
-                    assistito.setTs(DATI.DATA_NASCITA, nullArray(out.data.data.p801dataNascita));
-                    assistito.setTs(DATI.COMUNE_NASCITA, nullArray(out.data.data.p801comuneNascita));
-                    assistito.setTs(DATI.COD_COMUNE_NASCITA, nullArray(out.data.data.p801codiceComuneNascita));
-                    assistito.setTs(DATI.COD_ISTAT_COMUNE_NASCITA, nullArray(out.data.data.p801codiceistatiComuneNascita));
-                    assistito.setTs(DATI.INDIRIZZO_RESIDENZA, nullArray(out.data.data.p801recapitoTessera));
-                    assistito.setTs(DATI.COD_COMUNE_RESIDENZA, nullArray(out.data.data.p801codiceComuneResidenza));
-                    assistito.setTs(DATI.COD_ISTAT_COMUNE_RESIDENZA, nullArray(out.data.data.p801codiceistatiComuneResidenza));
-                    assistito.setTs(DATI.ASP, asp !== " -   - " ? asp : "");
-                    assistito.setTs(DATI.MMG_CF, nullArray(out.data.data.p801codiceFiscaleMedico));
-                    assistito.setTs(DATI.MMG_COGNOME, nullArray(out.data.data.p801cognomeMedico));
-                    assistito.setTs(DATI.MMG_NOME, nullArray(out.data.data.p801nomeMedico));
-                    assistito.setTs(DATI.MMG_DATA_SCELTA, nullArray(out.data.data.p801dataAssociazioneMedico));
-                    assistito.setTs(DATI.SSN_TIPO_ASSISTITO, nullArray(out.data.data.p801descrizioneCodiceTipoAssistito));
-                    assistito.setTs(DATI.SSN_INIZIO_ASSISTENZA, nullArray(out.data.data.p801dataInizioValidita));
-                    assistito.setTs(DATI.SSN_FINE_ASSISTENZA, out.data.data.p801dataFineValidita === "31/12/9999" ? "illimitata" : nullArray(out.data.data.p801dataFineValidita));
-                    assistito.setTs(DATI.SSN_MOTIVAZIONE_FINE_ASSISTENZA, out.data.data.p801dataFineValidita !== "31/12/9999" ? nullArray(out.data.data.p801motivazioneFineValidita) : null);
-                    assistito.setTs(DATI.SSN_NUMERO_TESSERA, nullArray(out.data.data.p801numeroTessera));
-                    assistito.setTs(DATI.DATA_DECESSO, deceduto ? nullArray(out.data.data.p801dataDecesso) : null);
-                    assistito.okTs = true;
-                    assistito.fullDataTs = out.data;
+                    // Mapping p801 → Assistito centralizzato in #popolaAssistitoDaP801, riusato
+                    // IDENTICO dal fallback legacy TS (la mappatura resta UNA SOLA e invariata).
+                    this.#popolaAssistitoDaP801(assistito, out.data.data, cf, out.data);
                     risultato = {
                         ok: true,
                         fullData: out.data,
@@ -2935,7 +3092,16 @@ export class Nar2 {
             }
         }
         if (!ok) {
-            console.log(`[getDatiAssistitoFromCfSuSogeiNew] Sogei fallito dopo ${this._maxRetry} tentativi per CF: ${cf?.substring(0, 6)}***`);
+            console.log(`[getDatiAssistitoFromCfSuSogeiNew] Sogei fallito dopo ${this._maxRetry} tentativi per CF: ${cf?.substring(0, 6)}*** — provo fallback legacy TS`);
+            try {
+                const fb = await this.#fallbackLegacyTsToP801(cf, assistito);
+                if (fb) {
+                    console.log(`[getDatiAssistitoFromCfSuSogeiNew] Fallback legacy TS riuscito (fonte: scraping portale)`);
+                    return fb;
+                }
+            } catch (e) {
+                console.log(`[getDatiAssistitoFromCfSuSogeiNew] Fallback legacy TS fallito:`, e.message);
+            }
             return {
                 ok: false,
                 fullData: null,
@@ -2977,9 +3143,34 @@ export class Nar2 {
         let p801 = sogeiData;
         if (!p801) {
             const sogei = await this.getDatiAssistitoFromCfSuSogeiNew(codiceFiscale);
-            if (!sogei?.ok) {
-                const esito = classificaStatoTs({fonte: "sogei", trovato: false}, {codiceAslAsp});
-                return {ok: false, cf: codiceFiscale, ...esito, anagrafica: null, raw: null, error: "Sistema TS (Sogei) non raggiungibile"};
+            // Sogei irraggiungibile OPPURE dato ricostruito dal fallback legacy: la
+            // classificazione dello stato passa dallo snapshot del PORTALE (Ts.getStatoAssistitoTs
+            // → snapshotDaPortale), che NON dipende da p801codiceTipoAssistito — inaffidabile dal
+            // portale (per i neonati mostra "3" → falso TRASFERITO). Così i neonati restano corretti.
+            if (!sogei?.ok || sogei?.fullData?._fonte === "legacy-ts") {
+                try {
+                    const st = await this.#tsScraper().getStatoAssistitoTs({codiceFiscale, codiceAslAsp});
+                    if (st?.ok) {
+                        const cval = (k) => { const x = st.coppie?.[k]; return x == null ? "" : String(x).trim(); };
+                        return {
+                            ok: true, cf: codiceFiscale,
+                            stato: st.stato, etichetta: st.etichetta, daFarRientrare: st.daFarRientrare,
+                            residenzaInAsp: st.residenzaInAsp, aslAssistenzaInAsp: st.aslAssistenzaInAsp,
+                            haMedico: st.haMedico, codiceTipoAssistito: st.codiceTipoAssistito,
+                            descrizioneTipoAssistito: st.descrizioneTipoAssistito,
+                            anagrafica: {cognome: cval("Cognome"), nome: cval("Nome"), sesso: cval("Sesso"), dataNascita: cval("Data Nascita")},
+                            fonte: "portale", evidenze: st.evidenze ?? [], raw: st.coppie ?? null
+                        };
+                    }
+                } catch (e) {
+                    console.log(`[getStatoAssistitoTs] Fallback portale fallito:`, e.message);
+                }
+                // Portale non disponibile: se Sogei è davvero irraggiungibile → errore.
+                // Se invece avevamo un dato legacy ricostruito, proseguo best-effort con esso.
+                if (!sogei?.ok) {
+                    const esito = classificaStatoTs({fonte: "sogei", trovato: false}, {codiceAslAsp});
+                    return {ok: false, cf: codiceFiscale, ...esito, anagrafica: null, raw: null, error: "Sistema TS (Sogei) non raggiungibile"};
+                }
             }
             if (sogei?.data?.okTs !== true) {
                 const esito = classificaStatoTs({fonte: "sogei", trovato: false}, {codiceAslAsp});

package/src/narTsServices/statoAssistitoTs.js

@@ -128,7 +128,7 @@ export function snapshotDaPortale({coppie = {}, menuVoci = [], trovato = true, d
 }
 
 // "190 - Sicilia 205 - ASP MESSINA" → "205"  (ultimo codice numerico = ASL)
-function estraiCodiceAsl(s) {
+export function estraiCodiceAsl(s) {
     const m = String(s || "").match(/(\d{3})\s*-\s*ASP|(\d{3})(?!.*\d{3})/i);
     if (!m) return null;
     return m[1] || m[2] || null;