gala-ki-spielwiese/database/packages/pck_auto_import.pkb

create or replace package body pck_auto_import as

    c_log_module          constant lg_app_log.log_module%type := 'AUTOMATISCHER_BA_IMPORT';

    PROCEDURE p_create_wv_autonomous(i_swv_bemerkung                 inkasso.sy_wiedervorlage.swv_bemerkung%TYPE DEFAULT NULL   
    ) 
    /*Kopf------------------------------------------------------------------------------------------------
    -- Beschreibung:  Erstellt eine Wiedervorlage innerhalb eine autonomous transaction, damit rollback/commits in Fehlerf<72>llen, diese Wiedervorlage nicht beeinflussen.
    ------------------------------------------------------------------------------------------------------
    -- Parameter: <20>
    ------------------------------------------------------------------------------------------------------
    -- MA   Datum       <20>nderung
    -- SCK  2026-04-27  Prozedur erstellt
    ------------------------------------------------------------------------------------------------Kopf*/
    is
    PRAGMA AUTONOMOUS_TRANSACTION;
    BEGIN
        pck_wiedervorlage.p_wiedervorlage_anlegen   (i_swv_stp_id_art               => pck_stammdaten.f_get_stp_id_by_programmid('WV_IMPORT_BA_KORRES') 
                                                    ,i_swv_wdatum                   => sysdate
                                                    ,i_swv_bemerkung                => i_swv_bemerkung --'Bitte manuell Pr<50>fen: Beim automatischen Import der BA-Datei "' || l_filename || '" ist folgende Fehler aufgetreten: "' || SQLERRM ||  '" (Siehe "' || i_object_key || '").'
                                                    ,i_swv_mit_id_wsachbearbeiter   => pck_system.f_get_par_wert_by_programmid('BA_IMPORT_SB_MIT_ID')
            );
        COMMIT;  -- Nur diese autonome Transaktion
    END;

    procedure p_run_ba_korrespondenz_dateieingang_automation
    /*Kopf------------------------------------------------------------------------------------------------
    -- Beschreibung:  Einstiegspunkt f<>r die APEX Automation (st<73>ndlich).
    --                Schritt 1: p_process_incoming_ba_data aufrufen <20> verarbeitet Batches, die bereits
    --                           in OCI liegen (Fallback f<>r den Fall, dass der ORDS-Aufruf im letzten
    --                           Quarkus-Lauf fehlgeschlagen ist).
    --                Schritt 2: Quarkus Dateieingang Service via HTTP POST ansto<74>en (fire & forget).
    --                           Schl<68>gt Schritt 2 fehl, l<>uft Schritt 1 beim n<>chsten Stundenlauf erneut.
    ------------------------------------------------------------------------------------------------------
    -- Parameter: <20>
    ------------------------------------------------------------------------------------------------------
    -- MA   Datum       <20>nderung
    -- SCK  2026-04-21  Prozedur erstellt
    ------------------------------------------------------------------------------------------------Kopf*/
    is
        l_service_url   varchar2(4000 char);
        l_api_key       varchar2(500 char);
        l_response      clob;
        l_http_status   number;
        l_log_action    constant varchar2(512 char) := 'BA_KORRESPONDENZEN_DATEIEINGANG_AUTOMATION';
        l_automaton_endpoint constant varchar2(256 char) := 'api/process-incoming-ba-korrespondenz';
    begin
        pck_log.p_info(
             i_module  => c_log_module
            ,i_action  => l_log_action
            ,i_message => 'Automation gestartet'
        );

        -- Offene Batches in OCI verarbeiten
        pck_log.p_info(
             i_module  => c_log_module
            ,i_action  => l_log_action
            ,i_message => 'Verarbeitung offener BA-Korrespondenz-Dateien aus OCI gestartet'
        );

        p_process_incoming_ba_data;

        pck_log.p_info(
             i_module  => c_log_module
            ,i_action  => l_log_action
            ,i_message => 'Verarbeitung offener BA-Korrespondenz-Dateien aus OCI abgeschlossen'
        );

        -- Quarkus ansto<74>en <20> Fehler werden geloggt, nicht eskaliert
        pck_log.p_info(
             i_module  => c_log_module
            ,i_action  => l_log_action
            ,i_message => 'Quarkus Dateieingang Service wird angesto<74>en'
        );
        begin
            l_service_url := pck_system.f_get_par_wert_by_programmid('AUTOMATON_BASE_URL') || l_automaton_endpoint;
            l_api_key     := pck_system.f_get_par_wert_by_programmid('AUTOMATON_API_KEY');

            apex_web_service.g_request_headers.delete;
            apex_web_service.g_request_headers(1).name  := 'X-Api-Key';
            --dbms_output.put_line(l_api_key);
            apex_web_service.g_request_headers(1).value := l_api_key;

            l_response    := apex_web_service.make_rest_request(
                 p_url         => l_service_url
                ,p_http_method => 'POST'
                ,p_wallet_path => pck_system.f_get_par_wert_by_programmid('NETSTORE_WALLET_PATH')
            );
            l_http_status := apex_web_service.g_status_code;

            case l_http_status
            when 202
            then
                pck_log.p_info(
                     i_module  => c_log_module
                    ,i_action  => l_log_action
                    ,i_message => 'BA Dateieingang Service angesto<74>en (202 Accepted)'
                );
            when 409
            then
                -- Service l<>uft bereits <20> kein Fehler, kein zweiter Lauf n<>tig
                pck_log.p_info(
                     i_module  => c_log_module
                    ,i_action  => l_log_action
                    ,i_message => 'BA Dateieingang Service l<>uft bereits (409 Conflict) <20> kein neuer Lauf gestartet'
                );
            else
                pck_log.p_error(
                     i_module  => c_log_module
                    ,i_action  => l_log_action
                    ,i_message => 'Fehler in BA Dateieingang Service: unerwarteter HTTP-Status ' || l_http_status
                    ,i_detail   => l_response
                );
            end case;
        exception
        when others
        then
            -- Quarkus-Aufruf fehlgeschlagen: loggen, nicht eskalieren.
            -- N<>chster Stundenlauf f<>hrt BA-Import-Schritt erneut aus.
            pck_log.p_error(
                 i_module  => c_log_module
                ,i_action  => l_log_action
                ,i_message => 'Aufruf des BA Dateieingang Service fehlgeschlagen: ' || sqlerrm
                ,i_detail  => to_clob(dbms_utility.format_error_backtrace)
            );
        end;
    end p_run_ba_korrespondenz_dateieingang_automation;

    procedure p_import_ba_korrespondenz (
         i_object_key    in varchar2
        ,i_content       in blob
        ,i_target_folder in varchar2
    )
    /*Kopf------------------------------------------------------------------------------------------------
    -- Beschreibung:  Importiert eine einzelne Datei aus dem OCI Eingangsordner in die Datenbank.
    --                Ruft inkasso.pck_import.f_import_ba_dokument auf.
    --                Bei R<>ckgabe 1 (Erfolg): Datei in den Zielordner verschieben.
    --                Bei R<>ckgabe != 1 (z.B. ung<6E>ltiger Dateiname): Warnung loggen und Exception werfen
    --                <20> Datei bleibt liegen, Commit/Rollback liegt beim Aufrufer.
    --                Kein Commit hier <20> wird von p_process_incoming_ba_data <20>bernommen.
    ------------------------------------------------------------------------------------------------------
    -- Parameter: i_object_key     Vollst<73>ndiger OCI-Objektkey der zu verarbeitenden Datei
    --            i_content        Dateiinhalt als BLOB
    --            i_target_folder  Zielordner-Prefix f<>r erfolgreich verarbeitete Dateien
    ------------------------------------------------------------------------------------------------------
    -- MA   Datum       <20>nderung
    -- SCK  2026-04-08  Stub erstellt
    -- SCK  2026-04-09  Implementierung: Aufruf f_import_ba_dokument, Wiedervorlage bei Fehler
    -- SCK  2026-04-09  Move nach erfolgreichem Import in p_import_ba_korrespondenz verschoben
    ------------------------------------------------------------------------------------------------Kopf*/
    is
        l_filename       varchar2(512);
        l_file_size      number;
        l_return         number;
        l_log_action     varchar2(512 char) := 'IMPORT_BA_PDF_FILE';
    begin
        -- Dateiname aus OCI-Objektkey ableiten (letztes Segment nach '/')
        l_filename  := substr(i_object_key, instr(i_object_key, '/', -1) + 1);
        l_file_size := dbms_lob.getlength(i_content);

        pck_log.p_info(
             i_module     => c_log_module
            ,i_action     => l_log_action
            ,i_message    => 'Import gestartet: "' || l_filename || '" (' || l_file_size || ' Bytes)'
            ,i_object_ref => i_object_key
        );

        begin
            l_return := inkasso.pck_import.f_import_ba_dokument(
                i_datei         => i_content
                ,i_dateiname     => l_filename
                ,i_datei_groesse => l_file_size
            );
        exception when others
        then
            rollback;
            pck_log.p_warn(
                 i_module     => c_log_module
                ,i_action     => l_log_action
                ,i_message    => 'Aufruf von pck_import.f_import_ba_dokument f<>r Datei "' || l_filename || '" hat einen Fehler geworfen ('  || SQLERRM || '). Erstelle wiedervorlage...'
                ,i_object_ref => i_object_key
            );
            
            -- Bei einem Import Fehler: Wiedervorlage f<>r Sachbearbeiter erstellen & Fehlermeldung mit in die Wiedervorlage schreiben
            p_create_wv_autonomous(i_swv_bemerkung => 'Bitte manuell Pr<50>fen: Beim automatischen Import der BA-Datei "' || l_filename 
                                                        || '" ist folgender Fehler aufgetreten: "' || SQLERRM ||  '" (Siehe "' || i_object_key || '").'
            );
            raise;
        end;

        if l_return != 1
        then
            pck_log.p_warn(
                 i_module     => c_log_module
                ,i_action     => l_log_action
                ,i_message    => 'Import f<>r Datei "' || l_filename || '" fehlgeschlagen (R<>ckgabe: ' || l_return || ') <20> Wiedervorlage erforderlich'
                ,i_object_ref => i_object_key
            );

            -- Wiedervorlage f<>r Sachbearbeiter erstellen
            p_create_wv_autonomous(i_swv_bemerkung => 'Bitte manuell Pr<50>fen: Die BA-Datei "' || l_filename || '" konnte nicht automatisch importiert werden (Siehe "' || i_object_key || '").'
            );

            pck_log.p_info(
                i_module     => c_log_module
                ,i_action     => l_log_action
                ,i_message    => 'Wiedervorlage angelegt.'
                ,i_object_ref => i_object_key
            );

            raise_application_error(-20000, 'Import fehlgeschlagen: "' || l_filename || '" (R<>ckgabe: ' || l_return || ')');
        end if;

        pck_log.p_info(
             i_module     => c_log_module
            ,i_action     => l_log_action
            ,i_message    => 'Datei "' || l_filename || '" erfolgreich importiert.'
            ,i_object_ref => i_object_key
        );

        -- Datei in Verarbeitet-Ordner verschieben
        pck_net_storage.p_move_object(
             i_object_key    => i_object_key
            ,i_target_prefix => i_target_folder
        );

        pck_log.p_info(
             i_module     => c_log_module
            ,i_action     => l_log_action
            ,i_message    => 'Datei "' || l_filename || '" erfolgreich verarbeitet und verschoben'
            ,i_object_ref => i_object_key
        );
    end p_import_ba_korrespondenz;

    procedure p_process_incoming_ba_data
    /*Kopf------------------------------------------------------------------------------------------------
    -- Beschreibung:  Verarbeitet alle fertigen Eingangs-Batches aus dem OCI Eingangsordner (Netzlaufwerk).
    --                Wird von ORDS-Endpunkt (von Quarkus Automaton) und aus Apex Automation aufgerufen.
    --                Pro Datei: Import + Move -> Commit; bei Exception: Rollback, Datei bleibt liegen,
    --                n<>chste Datei wird trotzdem verarbeitet.
    --                Nach dem Datei-Loop: DB-Marker immer l<>schen (verhindert erneuten Durchlauf).
    --                Wenn danach noch Dateien im Ordner liegen: Sachbearbeiter(SB)-Marker anlegen damit Sachbearbeiter
    --                die <20>briggebliebenen Dateien manuell pr<70>fen k<>nnen.
    ------------------------------------------------------------------------------------------------------
    -- MA   Datum       <20>nderung
    -- SCK  2026-04-08  Prozedur erstellt
    -- SCK  2026-04-09  Fehlerbehandlung: Datei bleibt liegen, Fehler-Marker, kein erneuter Durchlauf
    -- SCK  2026-04-09  SB-Marker statt l_had_errors-Flag; Move in p_import_ba_korrespondenz verschoben
    ------------------------------------------------------------------------------------------------Kopf*/
    is
        l_db_processing_marker_key  varchar2(1024);
        l_sb_marker_key             varchar2(1024);
        l_target_folder             varchar2(4000 char);
        l_target_prefix             varchar2(4000 char);
        l_eingang_prefix            varchar2(4000 char);
        l_zip_name                  varchar2(512);
        l_file_content              blob;
        l_meta                      pck_net_storage.t_object_meta;
        l_folders                   t_net_storage_tab;
        l_files                     t_net_storage_tab;
        l_has_remaining_files       boolean;
        l_log_action                varchar2(512 char) := 'IMPORT_BA_DATA';
    begin
        pck_log.p_info(
             i_module  => c_log_module
            ,i_action  => l_log_action
            ,i_message => 'BA-KORRESPONDENZEN IMPORT-START: Verarbeitung von eingehen BA Korrespondenzen gestartet'
        );

        -- Zielordner Name zusammenstellen
        l_target_prefix  := pck_system.f_get_par_wert_by_programmid('NETSTORE_TENANT_ID') || pck_system.f_get_par_wert_by_programmid('NETSTORE_BA_PREFIX') || pck_system.f_get_par_wert_by_programmid('NETSTORE_BA_KOR_ARC') || ' ' || to_char(sysdate, 'YYYY') || '/';
        l_eingang_prefix := pck_system.f_get_par_wert_by_programmid('NETSTORE_TENANT_ID') || pck_system.f_get_par_wert_by_programmid('NETSTORE_BA_PREFIX') || pck_system.f_get_par_wert_by_programmid('NETSTORE_BA_KOR_IM');

        -- Unterordner in eingangs-ordner auflisten (es gibt einen Ordner f<>r jeden entpackte ZIP-Datei)
        l_folders := pck_net_storage.f_list_objects(
             i_parent_folder      => l_eingang_prefix
            ,i_include_subfolders => 'N'
        );

        for rec_folder in (select object_key, is_folder from table(l_folders))
        loop
            -- Nur Unterordner verarbeiten
            if rec_folder.is_folder != 'Y'
            then
                continue;
            end if;

            pck_log.p_info(
                 i_module     => c_log_module
                ,i_action     => l_log_action
                ,i_message    => 'Datei-Ordner gefunden'
                ,i_object_ref => rec_folder.object_key
            );

            -- Der Marker ist eine Datei mit speziellem Namen, welche vom quarkus automaton in einen entpackten zip-ordner gelegt wird um zu signalisieren, dass alle Dateien des ZIPs erfolgreich in den ordner gelegt wurden.
            -- Das verhindert die verarbeitung von unvollst<73>ndig entpackten zips
            l_db_processing_marker_key := rec_folder.object_key || pck_system.f_get_par_wert_by_programmid('NETSTORE_MARKER_DB');

            pck_log.p_info(
                 i_module     => c_log_module
                ,i_action     => l_log_action
                ,i_message    => 'Marker f<>r Ordner wird gepr<70>ft. Marker: ' || l_db_processing_marker_key || ' in Ordner: ' || rec_folder.object_key
                ,i_object_ref => rec_folder.object_key
            );

            -- Marker pr<70>fen: -20001 = nicht vorhanden -> Upload noch nicht abgeschlossen
            begin
                l_meta := pck_net_storage.f_get_object_metadata(l_db_processing_marker_key);
            exception
            when others
            then
                if sqlcode = -20001
                then
                    pck_log.p_info(
                         i_module     => c_log_module
                        ,i_action     => l_log_action
                        ,i_message    => 'Kein DB-Verarbeitungsmarker vorhanden <20> Entpackter ZIP-Ordner wird <20>bersprungen (Upload noch nicht abgeschlossen)'
                        ,i_object_ref => rec_folder.object_key
                    );
                    continue;
                end if;
                raise;
            end;

            -- Zip-Namen aus Ordnerpfad ableiten: eingang/<zip-name>/ -> <zip-name>
            l_zip_name := substr(
                 rec_folder.object_key
                ,length(l_eingang_prefix) + 1
                ,length(rec_folder.object_key) - length(l_eingang_prefix) - 1
            );
            l_target_folder := l_target_prefix || l_zip_name || '/';

            pck_log.p_info(
                 i_module     => c_log_module
                ,i_action     => l_log_action
                ,i_message    => 'ZIP-START: Verarbeitung von entpacktem ZIP-Ordner gestartet <20> Zielordner: "' || l_target_folder || '"'
                ,i_object_ref => rec_folder.object_key
            );

            -- Alle Dateien im Unterordner auflisten (inkl. Unterordner = alle Tiefen)
            l_files := pck_net_storage.f_list_objects(
                 i_parent_folder      => rec_folder.object_key
                ,i_include_subfolders => 'Y'
            );

            for rec_file in (select object_key, is_folder from table(l_files))
            loop
                -- Marker und Pseudo-Ordner <20>berspringen
                if rec_file.object_key = l_db_processing_marker_key or rec_file.is_folder = 'Y'
                then
                    continue;
                end if;

                begin
                    pck_log.p_info(
                         i_module     => c_log_module
                        ,i_action     => l_log_action
                        ,i_message    => 'BA-Datei wird verarbeitet'
                        ,i_object_ref => rec_file.object_key
                    );

                    -- 1. Dateiinhalt laden
                    l_file_content := pck_net_storage.f_download_object(rec_file.object_key);

                    -- 2. Fachliche Verarbeitung + Move bei Erfolg (innerhalb p_import_ba_korrespondenz)
                    p_import_ba_korrespondenz(rec_file.object_key, l_file_content, l_target_folder);

                    -- Commit pro Datei: OCI-Move ist nicht transaktional, daher DB-<2D>nderungen sofort sichern 
                    -- sonst w<>rde ein Fehler bei einer sp<73>teren Datei den DB-Import bereits verschobener Dateien zur<75>ckrollen
                    commit;

                exception
                when others
                then
                    rollback;
                    pck_log.p_error(
                         i_module     => c_log_module
                        ,i_action     => 'IMPORT_FILE'
                        ,i_message    => 'Fehler bei Dateiverarbeitung: ' || sqlerrm
                        ,i_detail     => to_clob(dbms_utility.format_error_backtrace)
                        ,i_object_ref => rec_file.object_key
                    );
                end;
            end loop;

            -- DB-Marker immer entfernen <20> verhindert erneute Verarbeitung beim n<>chsten Lauf
            pck_net_storage.p_delete_object(l_db_processing_marker_key);

            pck_log.p_info(
                 i_module     => c_log_module
                ,i_action     => l_log_action
                ,i_message    => 'DB-Verarbeitungsmarker gel<65>scht'
                ,i_object_ref => l_db_processing_marker_key
            );

            -- Pr<50>fen ob noch Dateien im Unterordner liegen (nicht erfolgreich importierte Dateien)
            l_files := pck_net_storage.f_list_objects(
                 i_parent_folder      => rec_folder.object_key
                ,i_include_subfolders => 'Y'
            );

            l_has_remaining_files := false;

            for rec_remaining in (select object_key, is_folder from table(l_files))
            loop
                if rec_remaining.is_folder != 'Y'
                then
                    l_has_remaining_files := true;
                    exit;
                end if;
            end loop;

            if l_has_remaining_files
            then
                pck_log.p_warn(
                     i_module     => c_log_module
                    ,i_action     => l_log_action
                    ,i_message    => 'ZIP-ENDE: Entpackter ZIP-Ordner mit Fehlern abgeschlossen - mind. eine Datei konnte nicht importiert werden, SB-Marker wird hochgeladen...'
                    ,i_object_ref => rec_folder.object_key
                );

                -- Sachbearbeiter (SB)-Marker anlegen: signalisiert Sachbearbeitern, dass Dateien manuell gepr<70>ft werden m<>ssen
                l_sb_marker_key := rec_folder.object_key || pck_system.f_get_par_wert_by_programmid('NETSTORE_MARKER_SB');
                pck_net_storage.p_upload_object(
                     i_object_key   => l_sb_marker_key
                    ,i_content      => empty_blob()
                    ,i_content_type => 'application/octet-stream'
                );
                
            else
                pck_log.p_info(
                     i_module     => c_log_module
                    ,i_action     => l_log_action
                    ,i_message    => 'ZIP-ENDE: Entpackter ZIP-Ordner abgeschlossen, alle Dateien erfolgreich importiert'
                    ,i_object_ref => rec_folder.object_key
                );
            end if;
        end loop;


        pck_log.p_info(
             i_module  => c_log_module
            ,i_action  => l_log_action
            ,i_message => 'BA-KORRESPONDENZEN IMPORT-ENDE: Verarbeitung von eingehen BA Korrespondenzen abgeschlossen'
        );

    end p_process_incoming_ba_data;

end pck_auto_import;
/