/* MKS0074: Bildmodul mit Blätterlogik/Hinweisen/Dunkelverarbeitung */ MKS0074: PROC(P_DC_STEUER_PARM) %INCLUDE $CICSIMS; /* VersionxBildmodulskelett: B1.00 angepasst auf Anzeigemodul */ /********************************************************************/ /* */ /* PROGRAMM: MKS0074 */ /* */ /* PROJEKT: INPU_II : Schnellauskunft */ /* */ /* BILDNAME: KS074 - Policenauskunft */ /* */ /* PROGRAMMIERER: Schoenfeldt / NOVUM (fuer QV) */ /* */ /* ERSTELLUNGSDATUM: 18.10.1999 */ /* */ /* .---------------------. */ /**---------------------! BESCHREIBUNG !--------------------**/ /* '---------------------' */ /* */ /* Schnellauskunft f}r INPU-Vert{ge */ /* Bildmodul als Bl{tterprogramm f}r verschiedene Listen. */ /* Es gibt fixe Bereiche f}r Kopf und Fuss Informationen. */ /* Der variable mittleren Teil der Maske kann verschiedene */ /* Listen aufnehmen, die durchgebl{ttert werden. */ /* Im variablen Teil k¦nnen Eingaben vorgenommen (AUSW, Aktion) */ /* werden incl PF-Tasten, aus denen dann die Folgeliste sich */ /* ergibt. */ /* Realisiert sind Anforderungen von INPU_II : */ /* Schnellauskunft (Andrea Thom : 07/99) */ /* */ /* Realisationskonzept : Listenanzeige in INPU */ /* A. Generelles */ /* 1.) Standardisierte Behandlung von PF3, PF7/PF8, PF10, PF11 */ /* 2.) Anwendungslogik hinter DF, PF4/PF6, PF12 */ /* 3.) nicht unterst}tzt PF1, PF5, PF9 */ /* B. Aufgaben Standardbehandlung */ /* 1.) Aufruf der Folgedialoge */ /* 2.) Uebernahme der variablen Maskendaten : hier aktuelle Liste */ /* 3.) Blaetter_Logik innerhalb des Dialogs in der aktuellen Liste*/ /* C. Aufgaben Anwendungslogik */ /* 1.) Datenbereitstellung : hier fertige Listen */ /* ueber Stored Procedures und mittels Out-Parameter und */ /* Schnittstelle einer Global Temporary Table (Listen) */ /* 2.) Speichern und wiedereinlesen der Daten */ /* 3.) Eingabebehandlung und */ /* Selektion einer anzuzeigenden Liste */ /* 4.) Bereitstellen der Maskendaten : */ /* Liste */ /* Infodaten Kunde, Vertrag, Objekt, Zeilen */ /* D) Aufgaben der Stored Procedures */ /* 1.) Bereitstellen Policen- und Vertragsdaten */ /* 2.) Bereitstellen Listen gemaess Anforderungsprofil */ /* 3.) Listenverknuepfungen bereitstellen fuer interaktive */ /* Listenauswahl durch den Sachbearbeiter */ /* */ /* */ /* .---------------------. */ /**---------------------! [NDERUNGS-PROTOKOLL !--------------------**/ /* '---------------------' */ /* */ /* AEND000 Wann Wer WAS */ /* ------- -------- -------- ----------------------------------- */ /* 10/99 Schoenf. Erstanlage */ /* */ /* AEND001 11/99 Schoenf. KUKZ ueber MKI3050 ermitteln */ /* */ /* AEND002 04/01 Schoenf. Einbau GVLBOX und CarGarantie */ /* Vereinheitlichung der Variablenname */ /* Listennummern neu vergeben */ /* AEND003 02/03 Feurer Einbau GVL Karstadt */ /* AEND004 02/03 Kuhn neue Features fuer Karstadt eingeb. */ /* AEND005 03/05 Schoenfeldt/Scharrer: */ /* - Distinct-Spalten in Klammern setzen fuer */ /* neuen PL1-Compiler */ /* - Aenderung bei Aufbau AUSKUNFT_TAB: */ /* Anzahl max.Eintraege erhoeht auf 290 */ /* (MAX_AUSKUNFT) */ /* Programm-Abbruch falls auch dieser Wert */ /* ueberschritten werden sollte */ /* AEND005 05/05 Schoenfeldt : Quelle-Kundennummer entfaellt */ /* AMS/AIDA liefert sie nicht mehr */ /* Anzeige : KQV-Kundennummer in QKDNR-Feld */ /* Feldbezeichner flexibel fuellen */ /* */ /********************************************************************/ 1/********************************************************************/ /* */ /* G l o b a l e D e f i n i t i o n e n */ /* */ /********************************************************************/ /*------------------------------------------------------------------*/ /* Bildmodul nur für CICS */ /*------------------------------------------------------------------*/ %IF $SYSTEM ^= 'CICS' %THEN %DO; %NOTE('BILDMODUL IST NUR FUER CICS WANDELBAR !',16); %END; /*------------------------------------------------------------------*/ /* Allg. PL/I-Routinen / Builtins */ /*------------------------------------------------------------------*/ %INCLUDE BUILTIN2; /* PL/I-Builtins */ DCL STG BUILTIN; %INCLUDE DB2SQLCA; /* DB2-SQLCA */ %INCLUDE KQ$BILD ; /* QV-PL/I-Konstanten Bildmodule */ %INCLUDE $KQROUT ; /* QV-Routinen */ %INCLUDE $KQMACRO; /* QV-Macros */ %INCLUDE $KQONL ; /* QV-Online-Routinen */ %INCLUDE SMKV0007; /* HANDLE_SPA */ /*------------------------------------------------------------------*/ /* Konstanten dieser Transaktion */ /*------------------------------------------------------------------*/ DCL K_PGM_NAME CHAR(7) INIT('MKS0074'); DCL K_MOD_NAME CHAR(6) INIT('KS074D'); DCL K_TRAN_NAME CHAR(4) INIT('KS74'); DCL ATTR_CURSOR BIT(02) INIT('11'); %DCL $MAX_ZEILEN FIXED; /* $$$ Zeilen maximal */ %$MAX_ZEILEN = 99; /* AEND005A Wert erhoeht auf 290 */ /* %DCL $MAX_AUSKUNFT FIXED; /* $$$ Zeilen maximal */ /* %$MAX_AUSKUNFT =199; */ %DCL $MAX_AUSKUNFT FIXED; /* $$$ Zeilen maximal */ %$MAX_AUSKUNFT =290; /* AEND005E */ %DCL $MAX_HINWEIS FIXED; /* $$$ Maximale anz. Hinweise(Puffer)*/ %$MAX_HINWEIS = 10; %DCL $ZEILEN_SEITE FIXED; /* $$$ Zeilen pro Seite (Anzeige) */ %$ZEILEN_SEITE = 9; %DCL $MAX_PF12 FIXED; /* $$$ Zeilen im PF12_Stack */ %$MAX_PF12 = 20; /*AEND0002B*/ /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ %DCL $MAX_REF_F FIXED; /* $$$ Zeilen im PF12_Stack */ %$MAX_REF_F = 5; %DCL $MAX_Variable FIXED; /* max Zeilen im Variable_Tab */ %$MAX_Variable = 99; %DCL $MAX_Zus_Felder FIXED; %$MAX_Zus_Felder = 4; /*---neuHSC:Policenauskunft - Ende ---------------------------------*/ /*AEND0002E*/ /*------------------------------------------------------------------*/ /* SCHNITTSTELLE ZU DC-HAUPTPROGRAMM DC_INFO + DC_AKTION */ /*------------------------------------------------------------------*/ %INCLUDE SDC005DC; %INCLUDE X2000513; 1/********************************************************************/ /* */ /* B i l d s c h i r m a u s g a b e */ /* */ /********************************************************************/ /*------------------------------------------------------------------*/ /* MFS-ATTRIBUTDEFINITIONEN */ /*------------------------------------------------------------------*/ %INCLUDE SDP110DC; /*------------------------------------------------------------------*/ /* MID-MOD STANDARDDEFINITION */ /*------------------------------------------------------------------*/ %INCLUDE SDC003DC; /*------------------------------------------------------------------*/ /* MID-MOD KS074 */ /*------------------------------------------------------------------*/ %INCLUDE KS074D; 1/********************************************************************/ /* */ /* S P A */ /* */ /********************************************************************/ /*------------------------------------------------------------------*/ /* SCHNITTSTELLE ZUR DC-HAUPTPROGRAMM SPA */ /*------------------------------------------------------------------*/ %INCLUDE SDP001DC; /*------------------------------------------------------------------*/ /* PROJEKT - SPA */ /*------------------------------------------------------------------*/ %INCLUDE SKOSPA; /*------------------------------------------------------------------*/ /* LOKALE - SPA Sparte ... */ /*------------------------------------------------------------------*/ /* $$$ Include f}r Lokale (=Sparten)-SPA */ DCL 1 SPA_LOKAL UNAL BASED (ADDR(SPA.LOKAL)), %INCLUDE SKSSPAL; /*------------------------------------------------------------------*/ /* PROGRAMM- SPA */ /*------------------------------------------------------------------*/ DCL 1 PGMSPA BASED (ADDR(SPA.PROG)) /*----------------------------------------*/ /* Alt/Neu Historie f}r Anzeige */ /*----------------------------------------*/ ,3 VSNR CHAR(10) ,3 HISTNR_ALT DEC FIXED(5,0) ,3 HISTNR_NEU DEC FIXED(5,0) ,3 AENDDT_ALT CHAR(10) ,3 AENDDT_NEU CHAR(10) ,3 VORG_SCHL CHAR(4) /*----------------------------------------*/ /* Zeileninfo */ /*----------------------------------------*/ ,3 ANZ_ZEILEN BIN FIXED(15) ,3 AKT_SEITE BIN FIXED(15) ,3 AKT_ZEILE BIN FIXED(15) /*----------------------------------------*/ /* Hinweishandling */ /*----------------------------------------*/ ,3 ANZ_HINWEISE BIN fixed(15) ,3 AKT_HINWEIS BIN fixed(15) /*----------------------------------------*/ /* Hilfsfelder : Sicherung BS_Daten */ /*----------------------------------------*/ ,3 MOD_SPA LIKE KS074DA /*----------------------------------------*/ /* $$$ Anw.spez. Felder in PGMSPA */ /*----------------------------------------*/ /*----------------------------------------*/ /* Maskenstati */ /*----------------------------------------*/ ,3 SPA_ZUSTAND CHAR(1) ,3 AKT_AKTION CHAR(1) /*----------------------------------------*/ /* aktuelle Liste */ /*----------------------------------------*/ ,3 ANZ_ZEILEN_AK BIN FIXED(15) ,3 AKT_ZEILE_AK BIN FIXED(15) ,3 ERST_ZEILE_AK BIN FIXED(15) /*----------------------------------------*/ /* PI_AUSKUNFT = AUSKUNFT_TAB */ /*----------------------------------------*/ ,3 ANZ_PI_ZEILEN BIN FIXED(15) ,3 AKT_PI_ZEILE BIN FIXED(15) ,3 VOR_PI_ZEILE BIN FIXED(15) ,3 NXT_PI_ZEILE BIN FIXED(15) /*--------------------------------------------*/ /* Listeninfo fuer ermittle_Folgeliste / PF12 */ /*--------------------------------------------*/ ,3 PF12_MAX BIN FIXED(15) ,3 PF12_STACK ,4 PF12_REFERENZ (20) ,6 REF_LINR BIN FIXED(15) ,6 REF_ZEINR BIN FIXED(15) ,6 REF_SEITNR BIN FIXED(15) ,4 ZEIGER BIN FIXED(15) ,3 PF12_AKT_SEITE BIN FIXED(15) /*----------------------------------------*/ /* Listeninfo fuer ermittle_Folgeliste */ /*----------------------------------------*/ ,3 ANZ_LISTEN BIN FIXED(15) ,3 AKT_LISTE BIN FIXED(15) ,3 VOR_LISTE BIN FIXED(15) ,3 NXT_LISTE BIN FIXED(15) ,3 HISTBL_LISTE BIN FIXED(15) /*----------------------------------------*/ ,3 B_KOPF_KO CHAR(1) ,3 B_KOPF_KD CHAR(1) ,3 B_EINGABE CHAR(1) ,3 NEUAUFBAU CHAR(1) ,3 NEUHOLEN CHAR(1) /*----------------------------------------*/ ,3 ANZ_VERTRAEGE BIN FIXED(15) ,3 AKT_VERTRAG DEC FIXED(15,0) ,3 VOR_VERTRAG DEC FIXED(15,0) ,3 NXT_VERTRAG DEC FIXED(15,0) /*----------------------------------------*/ ,3 AKT_HISTNR DEC FIXED(05,0) ,3 VOR_HISTNR DEC FIXED(05,0) ,3 NXT_HISTNR DEC FIXED(05,0) /*----------------------------------------*/ ,3 AKT_AENDDT CHAR(10) ,3 VOR_AENDDT CHAR(10) ,3 NXT_AENDDT CHAR(10) /*----------------------------------------*/ ,3 ANZ_OBJEKTE BIN FIXED(15) ,3 AKT_OBJEKT BIN FIXED(15) ,3 VOR_OBJEKT BIN FIXED(15) ,3 NXT_OBJEKT BIN FIXED(15) /*----------------------------------------*/ ,3 STATISTIK ,4 AKT_V_LFDNR BIN FIXED(15) ,3 AKT_O_LFDNR BIN FIXED(15) ,3 AKT_L_LFDNR BIN FIXED(15) /*----------------------------------------*/ ; /*********************************************************************/ /* */ /* E X T . U N T E R P R O G R A M M E */ /* */ /*********************************************************************/ /*-------------------------------------------------------------------*/ /* TRANSAKTIONSSTEUERUNG */ /*-------------------------------------------------------------------*/ %INCLUDE $KQTRAN; /*-------------------------------------------------------------------*/ /* FEHLER-ABBRUCH-PANEL */ /*-------------------------------------------------------------------*/ %INCLUDE XKO0997P ; XKO0997.P_SQLCA = ADDR(SQLCA); /*-------------------------------------------------------------------*/ /* KOPFDATEN */ /*-------------------------------------------------------------------*/ %INCLUDE XKO3066P ; XKO3066.P_SQLCA = ADDR(SQLCA); /*-------------------------------------------------------------------*/ /* LESEN TBKO_MELDUNGEN */ /*-------------------------------------------------------------------*/ %INCLUDE XKO5038P ; XKO5038.P_SQLCA = ADDR(SQLCA); /*-------------------------------------------------------------------*/ /* LESEN TBKO_KON_PGM_TXT */ /*-------------------------------------------------------------------*/ %INCLUDE XKO5096P ; XKO5096.P_SQLCA = ADDR(SQLCA); /*-------------------------------------------------------------------*/ /* VERWALTUNG TBKS_PGM_SCHWEBE */ /*-------------------------------------------------------------------*/ %INCLUDE XKQ6100P ; XKQ6100.P_SQLCA = ADDR(SQLCA); /*------------------------------------------------------------------*/ /* PARAMETER MKI3011 */ /* KAVIS-DATEN LESEN */ /*------------------------------------------------------------------*/ %INCLUDE XKI3011; /*------------------------------------------------------------------*/ /* PARAMETER MKI3050 */ /* LESEN KAVIS-DATEN Kunden-Kennzeichen */ /*------------------------------------------------------------------*/ %INCLUDE XKI3050; /*AEND001B*/ /*------------------------------------------------------------------*/ /* PARAMETER MKI3502 */ /* LESEN TBKI_KUKZ KO1103#MK */ /*------------------------------------------------------------------*/ /* %INCLUDE XKI3502P; */ /*AEND001E*/ /*------------------------------------------------------------------*/ /* PARAMETER MKI3060 */ /* KAVIS-DATEN LESEN Quelle-Kundennummer */ /*------------------------------------------------------------------*/ %INCLUDE XKI3060; /*********************************************************************/ /* EA - MODULE BESTAND */ /*********************************************************************/ /* $$$ ]bergabebereiche f}r ext. EA-MODULE BESTAND */ /*********************************************************************/ /* FACHL. FUNKTIONEN */ /*********************************************************************/ /* $$$ ]bergabebereiche f}r ext. fachl. Funktionen */ 1/*********************************************************************/ /* */ /* K O N S T A N T E N */ /* */ /*********************************************************************/ /*-------------------------------------------------------------------*/ /* Allg. Konstanten */ /*-------------------------------------------------------------------*/ DCL K_RC_OK BIN FIXED(31) INIT(0); /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ DCL K_N_NULL BIN FIXED(31) INIT(0); /*---neuHSC:Policenauskunft - Ende ---------------------------------*/ DCL K_FELDNULL CHAR(1) INIT('*'); DCL K_AUSKUNFT CHAR(4) INIT('8000'); DCL K_ERSTAUFRUF CHAR(1) INIT('E'); DCL K_FOLGEAUFRUF CHAR(1) INIT('F'); DCL K_SN_ZEITAB BIN FIXED(15) INIT(10000); DCL K_SN_AUSKUNFT BIN FIXED(15) INIT(11000); DCL K_SN_HINWEIS BIN FIXED(15) INIT(12000); /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ DCL K_LI_Variable BIN FIXED(15) INIT(1); /*---neuHSC:Policenauskunft - Ende ---------------------------------*/ DCL K_LI_VTRAUS BIN FIXED(15) INIT(10); DCL K_LI_VTROBJ BIN FIXED(15) INIT(20); DCL K_LI_VTRSON BIN FIXED(15) INIT(20); /*-------------------------------------------------------------------*/ /* Konstanten für MKQ6100 - Funktionen */ /*-------------------------------------------------------------------*/ DCL K_SCHW_SAVE CHAR(1) INIT('1'); DCL K_SCHW_LOAD CHAR(1) INIT('2'); DCL K_SCHW_DEL CHAR(1) INIT('3'); /*-------------------------------------------------------------------*/ /* Stored-Procedure Returncodes */ /*-------------------------------------------------------------------*/ DCL K_SP_OK BIN fixed(15) INIT(0); DCL K_SP_WARNUNG BIN fixed(15) INIT(4); DCL K_SP_AUSSTEUERN BIN fixed(15) INIT(8); DCL K_SP_ABBRUCH BIN fixed(15) INIT(16); /*-------------------------------------------------------------------*/ /* Aktionscode vor Merkmalen */ /*-------------------------------------------------------------------*/ DCL K_AKT_X CHAR(1) INIT('X'); DCL K_AKT_T CHAR(1) INIT('T'); DCL K_AKT_B CHAR(1) INIT('B'); DCL K_AKT_I CHAR(1) INIT('I'); DCL K_AKT_L CHAR(1) INIT('L'); 1/*********************************************************************/ /* */ /* Z w i s c h e n s p e i c h e r und B l { t t e r l o g i k */ /* */ /*********************************************************************/ /*------------------------------------------------------------------*/ /* TABELLE ZUR SPEICHERUNG ALLER ZEILENINHALTE (DYN. ALLOKIERT) */ /*------------------------------------------------------------------*/ DCL P_ZEILEN_TAB POINTER; DCL 1 ZEILEN_TAB BASED(P_ZEILEN_TAB) ,2 ANZAHL_ZEILEN BIN FIXED(15) ,2 EINTRAG($MAX_ZEILEN) ,4 AKTION0 ,6 AKTIONA BIT(16) ,6 AKTIONE(1) ,8 AKTIONT BIT(8) ,8 AKTIONV BIT(8) ,6 AKTION CHARACTER(1) ,4 LNR BIN FIXED(15) ,4 ZNR BIN FIXED(15) ,4 TEXT CHARACTER(76) ,4 VTRNR DEC FIXED(15,0) ,4 ONR BIN FIXED(15) ,4 ANZ_RF BIN FIXED(15) ,4 REF_TAB ($MAX_REF_F) ,6 AKT_CODE CHAR(01) ,6 LIS_ZEINR BIN FIXED(15) ; /*------------------------------------------------------------------*/ /* TABELLE AUSKUNFT (Zwischenspeicher GTT, Zeilen_Tab) */ /*------------------------------------------------------------------*/ DCL P_AUSKUNFT_TAB POINTER; DCL 1 AUSKUNFT_TAB BASED(P_AUSKUNFT_TAB) ,2 ANZAHL_ZEILEN BIN FIXED(15) ,2 EINTRAG($MAX_AUSKUNFT) ,4 LNR BIN FIXED(15) ,4 ZNR BIN FIXED(15) ,4 TEXT CHAR(76) ,4 VTRNR DEC FIXED(15,0) ,4 ONR BIN FIXED(15) ,4 ANZ_RF BIN FIXED(15) ,4 REF_TAB ($MAX_REF_F) ,6 AKT_CODE CHAR(01) ,6 LIS_ZEINR BIN FIXED(15) ; /*------------------------------------------------------------------*/ /* aktuelle Liste aus Auskunft (Zwischenspeicher vor Zeilen_Tab) */ /*------------------------------------------------------------------*/ DCL P_AKTLISTE_TAB POINTER; DCL 1 AKTLISTE_TAB BASED(P_AKTLISTE_TAB) ,2 ANZAHL_ZEILEN BIN FIXED(15) ,2 EINTRAG($MAX_AUSKUNFT) ,4 LNR BIN FIXED(15) ,4 ZNR BIN FIXED(15) ,4 TEXT CHAR(76) ,4 VTRNR DEC FIXED(15,0) ,4 ONR BIN FIXED(15) ,4 ANZ_RF BIN FIXED(15) ,4 REF_TAB ($MAX_REF_F) ,6 AKT_CODE CHAR(01) ,6 LIS_ZEINR BIN FIXED(15) ; /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ /*------------------------------------------------------------------*/ /* aktuelle Liste der Variablen fuer den Kopfbereich (u.a) */ /*------------------------------------------------------------------*/ /* Zuordnung der Listennummern */ /* LNR = 1 : Policenattribute Erzeugt MKS1314 einmal fest */ /* LNR = 2 : Vertragsattribute Erzeugt MKS1315 je Aufruf neu */ /* LNR = 3 : Objektattribute " */ /* LNR = 4 : Lvb_Attribute " */ DCL P_VARIABLE_TAB POINTER; DCL 1 VARIABLE_TAB BASED(P_VARIABLE_TAB) ,2 ANZAHL_VARIABLE BIN FIXED(15) ,2 EINTRAG($MAX_VARIABLE) ,4 LNR BIN FIXED(15) ,4 ZNR BIN FIXED(15) ,4 TEXT CHAR(76) ,4 VTRNR DEC FIXED(15,0) ,4 ONR BIN FIXED(15) ; DCL 1 L_VAR_SATZ ,4 LNR BIN FIXED(15) ,4 ZNR BIN FIXED(15) ,4 TEXT CHAR(76) ,4 VTRNR DEC FIXED(15,0) ,4 ONR BIN FIXED(15) ; DCL 1 VARIABLE_ZEILE ,2 T1 CHAR(10) ,2 VAR_NUMMER CHAR(04) ,2 T2 CHAR(02) ,2 VAR_NAME CHAR(24) ,2 T3 CHAR(02) ,2 VAR_WERT CHAR(20) ,2 REST CHAR(14) ; DCL 1 TAB_ZUSATZ_INFOS ,2 ANZAHL_FELDER BIN FIXED(15) ,2 EINTRAG($MAX_ZUS_FELDER) ,4 LFDNR BIN FIXED(15) ,4 BS_FELD_NAME CHAR(7) ,4 VARIABLEN_NAME CHAR(24) ; /*---neuHSC:Policenauskunft - Ende ---------------------------------*/ /*------------------------------------------------------------------*/ /* TABELLE FUER ANZUZEIGENDE HINWEISE */ /*------------------------------------------------------------------*/ DCL P_HINWEIS_TAB POINTER; DCL 1 HINWEIS_TAB($MAX_HINWEIS) BASED(P_HINWEIS_TAB) ,2 TEXT CHAR(79) ; 1/*********************************************************************/ /* */ /* D B 2 */ /* */ /*********************************************************************/ DCL O_ZAEHLER BIN FIXED(15); DCL ANZ_LI_ZEI BIN FIXED(15); DCL ANZ_LI_ZEI_V BIN FIXED(15); /*-------------------------------------------------------------------*/ /* DCLGEN FUER GTKS_PI_AUSKUNFT */ /*-------------------------------------------------------------------*/ %INCLUDE TKS0304; /* Indikatoren : */ DCL IND_ZTEXT BIN FIXED(15); DCL IND_VTRNR BIN FIXED(15); DCL IND_ONR BIN FIXED(15); DCL IND_AKT1 BIN FIXED(15); DCL IND_LNR1 BIN FIXED(15); DCL IND_AKT2 BIN FIXED(15); DCL IND_LNR2 BIN FIXED(15); DCL IND_AKT3 BIN FIXED(15); DCL IND_LNR3 BIN FIXED(15); DCL IND_AKT4 BIN FIXED(15); DCL IND_LNR4 BIN FIXED(15); DCL IND_AKT5 BIN FIXED(15); DCL IND_LNR5 BIN FIXED(15); /*-------------------------------------------------------------------*/ /* DCLGEN FUER TBKO_VTRJournal : vertragsjournal */ /*-------------------------------------------------------------------*/ %INCLUDE TKO0019; /* TBKO_VTRJOURNAL */ /* DCLGEN FUER TBKO_Vertragsart : Bezeichnungen fuer vertragskateg. */ /*-------------------------------------------------------------------*/ %INCLUDE TKO0020; /* TBKO_Vertragskat */ /*-------------------------------------------------------------------*/ /* DCLGEN FUER GTKS_PI_HINWEIS */ /*-------------------------------------------------------------------*/ %INCLUDE TKS0301; /*-------------------------------------------------------------------*/ /* CURSOR C_GET_DIALOG */ /* - AUS GTT DIE ANZUZEIGENDEN ZEILEN SELEKTIEREN */ /*-------------------------------------------------------------------*/ EXEC SQL DECLARE C_GET_AUSKUNFT CURSOR FOR SELECT LNR, ZNR, ZTEXT, AKT1, LNR1, AKT2, LNR2, AKT3, LNR3, AKT4, LNR4, AKT5, LNR5, VTRNR, ONR FROM GTKS_PI_AUSKUNFT ORDER BY LNR, ZNR ASC FOR FETCH ONLY ; /*-------------------------------------------------------------------*/ /* CURSOR C_GET_HINWEISE */ /* - AUS GTT DIE ANZUZEIGENDEN HINWEISE SELEKTIEREN */ /*-------------------------------------------------------------------*/ EXEC SQL DECLARE C_GET_HINWEISE CURSOR FOR SELECT ZNR, HINWEIS FROM GTKS_PI_HINWEIS ORDER BY ZNR ASC FOR FETCH ONLY ; /*-------------------------------------------------------------------*/ /* Stored Procedure Hostvariable */ /*-------------------------------------------------------------------*/ /* allgemein--------------------------------------------------------*/ DCL SP_EC BIN FIXED(31), SP_RC BIN FIXED(31), SP_MESSAGE CHAR(500) VARYING; /* MKS1314----------------------------------------------------------*/ DCL SP14_MANDANT CHAR(1), SP14_SPRACHCODE CHAR(1), SP14_VSNR CHAR(10), SP14_start_liste BIN FIXED(15), SP14_BEARBNR BIN FIXED(15), SP14_TITEL CHAR(12), SP14_NAME CHAR(30), SP14_VNAME CHAR(20), SP14_ADRSTR CHAR(35), SP14_ADRORT CHAR(35), SP14_GEBDAT CHAR(10), SP14_TELEFON CHAR(20), SP14_KUNDENKZ CHAR(50), SP14_QKDNR CHAR(20), SP14_EC BIN FIXED(31), SP14_ERRMSG CHAR(500) VARYING, SP14_RC BIN FIXED(31); /* MKS1315----------------------------------------------------------*/ DCL SP15_MANDANT CHAR(1), SP15_SPRACHCODE CHAR(1), SP15_VTRNR DEC FIXED(15,0), SP15_start_liste BIN FIXED(15), SP15_HISTNR DEC FIXED(5,0), SP15_BEARBNR BIN FIXED(15), SP15_AENDDT CHAR(10), SP15_VTRBEGDT CHAR(10), SP15_PRODUKT CHAR(50), SP15_BANKEZ CHAR(1), SP15_JNETTO CHAR(12), SP15_EC BIN FIXED(31), SP15_ERRMSG CHAR(500) VARYING, SP15_RC BIN FIXED(31); 1/*********************************************************************/ /* */ /* L O K A L E D A T E N */ /* */ /*********************************************************************/ /*-------------------------------------------------------------------*/ /* Standardvariablen */ /*-------------------------------------------------------------------*/ DCL H_MANDANT CHAR(01) ; DCL H_SPRACHCODE CHAR(01) ; /* Akt. Datum */ DCL TAGESDATUM CHAR(10) ; /* Anzuzeigende MeldId aus TBKO_MELDUNGEN */ DCL MELDUNGEN_ID CHAR(07) ; /* Kennzeichen, ob fachl. Fehler in Verarbeitung */ DCL B_FEHLER BIT(1) ALIGNED ; /* Kennzeichen, ob Dunkeldurchlauf */ DCL B_DUNKEL BIT(1) ALIGNED ; /*-------------------------------------------------------------------*/ /* Globale Variablen */ /*-------------------------------------------------------------------*/ /* $$$ Weitere globale Variablen des Bildmoduls */ 1/********************************************************************/ /********************************************************************/ /** **/ /** S T E U E R U N G **/ /** **/ /**----------------------------------------------------------------**/ /** MAIN - PROGRAM: Standardisierte Bildmodulsteuerung **/ /** **/ /********************************************************************/ /********************************************************************/ /* Hauptsteuerung */ /*---------------------------------------------*/ /* Initialisierungen je Aufruf */ /*---------------------------------------------*/ CALL GRUNDWERTE; /*---------------------------------------------*/ /* Verteilen Erst-/Folgeaufruf */ /*---------------------------------------------*/ IF ( DC_INFO.ERSTAUFRUF = K_JA ) THEN CALL ERSTAUFRUF; ELSE IF ( DC_INFO.RESTORE = ' ' ) then CALL FOLGEAUFRUF; ELSE CALL RESTORE; /*END-IF-restore*/ /*END-IF-erstaufruf/folgeaufruf*/ /*------------------------------------------------*/ /* MOD Aufbereitung/Aufraeumarbeiten */ /*------------------------------------------------*/ CALL ENDE_ROUTINE; /* Ende Hauptsteuerung */ 1/********************************************************************/ /* */ /* G R U N D W E R T E */ /* */ /*------------------------------------------------------------------*/ /* Initialisieren von Feldern je Aufruf */ /* */ /********************************************************************/ GRUNDWERTE: PROC REORDER; %INCLUDE SKOCUAD8; /*-----------------------------------------------------------*/ /* AUSGABE-STRUKTUR INITIALISIEREN UND MODLAENGE BELEGEN */ /*-----------------------------------------------------------*/ KS074DA = ''; KS074DA.KS074DAL = CSTG( KS074DA ); KS074DA.PERSNR = DC_INFO.PERSNR ; /*-----------------------------------------------------------*/ /* Setzen von SPA-Daten f}r Kompass */ /*-----------------------------------------------------------*/ SPA.PROJEKT.PGMNAME = 'MKS0074'; SPA.PROJEKT.VONTRAN = 'KS74'; DC_AKTION.SPERREN_PF = K_JA; /*-----------------------------------------------------------*/ /* Setzen von Standardwerten für Transaktionssteuerung */ /*-----------------------------------------------------------*/ CALL TS_INIT('KS74', P_DC_STEUER_PARM, ADDR(SQLCA), U_SPA.MANDANT, U_SPA.SPRACHCODE); /*-----------------------------------------------------------*/ /* Setzen von Grundwerte f}r MKO0997 - Abbruch */ /*-----------------------------------------------------------*/ XKO0997.P_SQLCA = ADDR(SQLCA); XKO0997.ANW_FEHLER(*) = ' '; SPA.FEHL_INFO.UPGM = K_PGM_NAME; /*-----------------------------------------------------------*/ /* Setzen von Programminternen Feldern */ /*-----------------------------------------------------------*/ TAGESDATUM = GET_DATE(); MELDUNGEN_ID = ' '; B_FEHLER = K_FALSE; H_MANDANT = '1'; H_SPRACHCODE = 'D'; /* $$$ Inits f}r jeden Aufruf */ PGMSPA.B_EINGABE = K_NEIN; PGMSPA.AKT_AKTION = ' '; /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ L_VAR_SATZ.LNR = 0; L_VAR_SATZ.ZNR = 0; L_VAR_SATZ.TEXT = ''; L_VAR_SATZ.VTRNR = 0.0; L_VAR_SATZ.ONR = 0; /*-----------------------------------------------------------*/ /* Setzen von Programminternen Feldern */ /*-----------------------------------------------------------*/ CALL INIT_Zusatz_Info_Felder; /*---neuHSC:Policenauskunft - Ende ---------------------------------*/ /*---------------------------------------------*/ /* Dyn. Speicher Allokieren */ /*---------------------------------------------*/ CALL GET_MAIN; END GRUNDWERTE; 1/********************************************************************/ /* */ /* E R S T A U F R U F */ /* */ /*------------------------------------------------------------------*/ /* Verarbeitung bei Erstaufruf */ /* - Pr}fen via MKO3099, ob Aufruf erlaubt */ /* - Transaktion festlegen */ /* - PGMSPA initialisieren */ /* - ermitteln Erstmaske */ /* Aufbaubereiten der ersten Maske */ /* 1 Maske zur Auswahl eines Vertrages zur VSNR */ /* oder */ /* 2 Maske mit ersten Informationen zu dem einen Vertrag */ /* 3 Sichern aktuelle Listeninformationen */ /* in PGMSPA und PGM-SCHWEBE */ /* */ /********************************************************************/ ERSTAUFRUF: PROC REORDER; /*-----------------------------------------------------*/ /* Erstaufruf - Pr}fen, ob Aufruf erlaubt */ /*-----------------------------------------------------*/ IF ( ^TS_PRUEF() ) THEN DO; CALL TS_BEARBVOR(K_TS_BEARBZYKLUS,' '); DC_INFO.ERSTAUFRUF = 'N'; RETURN; END; /*END-IF-ts_pruef*/ /*-----------------------------------------------------*/ /* HIER WIRD DAS ERSTE AUFZUBAUENDE BILD FESTGELEGT */ /*-----------------------------------------------------*/ DC_AKTION.NEU_TRANS = ' '; DC_AKTION.NEU_MOD = 'KS074'; /*-----------------------------------------------------*/ /* L¦schen PGMSPA oder initialisieren Felder einmalig */ /*-----------------------------------------------------*/ SPA.PROJEKT.VORG_SCHL = K_AUSKUNFT; /*-------- kommt nie vor, weil Auskunft nur Anzeige */ SPA.PROJEKT.NACHHIST = K_NEIN; SPA.SCHW_HISTNR = ''; SPA.SCHW_AENDDT = ''; /*----------------------- interne Tabellen loeschen */ /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ VARIABLE_TAB = ''; /*---neuHSC:Policenauskunft - Ende ---------------------------------*/ ZEILEN_TAB = ''; AKTLISTE_TAB = ''; AUSKUNFT_TAB = ''; HINWEIS_TAB = ''; /*------------------------- Anpassungen/Erg{nzungen */ CALL INIT_PGMSPA; /*------------------------------------------------------------*/ /* erste Maske vorbereiten */ /*------------------------------------------------------------*/ /* Aufbau der Liste : VTRAUS (oder VTROBJ ff bei nur 1 Vtrg) */ /* incl wegspeichern in PGM_SCHWEBE und ggf durch */ /* - Simulieren einer Eingabe */ /* - und Dunkeldurchlauf fordern (Verarbeitung : */ /*------------------------------------------------------------*/ CALL ERSTLISTE; /*-----------------------------------------------------*/ /* Prüfen, ob Dunkeldurchlauf: B_Eingabe = 'Ja' */ /* Bereitstellen der aktuellen Liste in AKTLISTE_TAB */ /* neu: zwischenspeichern aller benoetigten fixen */ /* Informationen (VN, PVOL_Attr, Stat) */ /*-----------------------------------------------------*/ IF ( DUNKEL_DURCHLAUF() ) THEN DO; CALL VERARBEITUNG; CALL ERSTES_OBJEKTAUSWAEHLEN; /* AEND004 */ IF ( PGMSPA.SPA_ZUSTAND = 'B' ) THEN DO; CALL MELDEN_BEARBEITET; DC_INFO.ERSTAUFRUF = 'N'; RETURN; END; /*END-IF-zustand*/ END; /*END-IF-dunkel_durchlauf*/ /*-----------------------------------------------------*/ /* F}llen von festen Feldern im MOD */ /*-----------------------------------------------------*/ /* Aufbereiten Kopfdaten - Kompass Standardteile */ /*-----------------------------------------------------*/ /* ist in Verarbeitung gerutscht, da abh. von Histnr, */ /* die in der Verarbeitung ermittelt wird */ /* Füllen Bild_Ueberschriften bei Erstaufruf */ /*-----------------------------------------------------*/ SPA.PROJEKT.TEVORG_BEZ = LESE_PGMTEXT(1); KS074DA.VORGBEZ = SPA.PROJEKT.TEVORG_BEZ; IF (SPA.PROJEKT.VSNR = '' & SPA.PROJEKT.VTRNR = '') ! SPA.PROJEKT.VTRNR = 0 THEN SPA.PROJEKT.VTRKATKZ = 300.0; ELSE SPA.PROJEKT.VTRKATKZ = GET_VTRJOUR_VTRKATKZ(SPA.PROJEKT.VSNR, SPA.PROJEKT.VTRNR); /*END-IF-spa_projekt*/ KS074DA.VARTBZ = ERM_VTRKAT(SPA.PROJEKT.VTRKATKZ); SPA.VARTBZ = KS074DA.VARTBZ; IF U_SPA.MANDANT = '3' THEN KS074DA.KDNRFELD = 'NV-KD '; ELSE KS074DA.KDNRFELD = 'KQV-KD '; /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ /* Fuellen Informationen im fixe Bildschirmfelder */ /*-----------------------------------------------------*/ CALL FIX_AUFBAU_MOD; /*---neuHSC:Policenauskunft - Ende ---------------------------------*/ /* Hinweis bei nachzufahrender Historie */ /*-----------------------------------------------------*/ IF ( SPA.PROJEKT.NACHHIST = K_JA ) THEN MELDUNGEN_ID = 'KO0674E' ; /*END-IF-nachhist*/ /*-----------------------------------------------------*/ /* F}llen vom Listenbereich im MOD */ /*-----------------------------------------------------*/ /* MOD aufbauen : Bildschirmfelder f}llen */ /* aus Tabelle AKTLISTE_TAB */ /* in Verarbeitung erstellt */ /*-----------------------------------------------------*/ CALL AUFBAU_MOD; END ERSTAUFRUF; 1/********************************************************************/ /* */ /* F O L G E A U F R U F */ /* */ /*------------------------------------------------------------------*/ /* - Prüfen, ob von Fehlerbild (Falls ja, => KO01) */ /* - MID aufbereitet in MOD kopieren */ /* - Verarbeitung abh{ngig von gedr}ckter Taste anstossen */ /* - Aufbau MOD, falls keine neue Transaktion */ /* */ /********************************************************************/ FOLGEAUFRUF: PROC REORDER; DCL H_ANZ_ZEILEN BIN FIXED(31) INIT(0); /*-----------------------------------------------------*/ /* Falls von Fehlerbild, dann Sprung nach KO01 */ /*-----------------------------------------------------*/ IF ( DC_INFO.VON_MOD = 'KO997' ) THEN DO; DC_AKTION.NEU_TRANS = 'KO01'; RETURN; END; /*END-IF-von_mod*/ /*-----------------------------------------------------*/ /* Dyn. Zeilentabelle laden aus TBKS_PGM_SCHWEBE */ /*-----------------------------------------------------*/ CALL PGM_SCHWEBE(K_SCHW_LOAD,K_SN_ZEITAB, P_ZEILEN_TAB,CSTG(ZEILEN_TAB)); CALL PGM_SCHWEBE(K_SCHW_LOAD,K_SN_HINWEIS, P_HINWEIS_TAB,CSTG(HINWEIS_TAB)); /*------------------------------------------------------*/ /* Lesen der als Auskunft_Tab gespeicherten PI_AUSKUNFT */ /* Erzeugen der aktuellen Liste, die zur letzen Ausgabe */ /* passt und Grundlage der letzten ZEILEN_TAB war */ /* inclusive der (neuen) Variable_Liste */ /*------------------------------------------------------*/ /* aktuelle AUSKUNFT_TAB, die zur letzten Anzeige passt */ H_ANZ_ZEILEN = HOLE_AKT_AUSKUNFT(); IF H_ANZ_ZEILEN ^= PGMSPA.ANZ_PI_ZEILEN /* eventuell falsche auskunft geholt : */ THEN CALL FEHLER(DUMMY0,'KS7402E'); IF H_ANZ_ZEILEN = 0 /* eventuell falsche auskunft geholt : */ THEN DO; CALL FEHLER(DUMMY0,'KS7411E'); DC_MID_8.TASTE = K_PF_03; END; /*END-IF-hole_akt_Auskunft*/ IF H_ANZ_ZEILEN > 0 THEN DO; /* aktuelle AKTLISTE_TAB, die zur letzten Anzeige passt */ H_ANZ_ZEILEN = HOLE_AKT_LISTE(PGMSPA.AKT_PI_ZEILE); IF H_ANZ_ZEILEN > 0 & H_ANZ_ZEILEN ^= PGMSPA.ANZ_ZEILEN_AK /* eventuell falsche liste geholt : ermitteln nxt liste */ THEN CALL FEHLER(DUMMY0,'KS7403E'); /*END-IF-hole_akt_Liste*/ IF H_ANZ_ZEILEN = 0 /* eventuell falsche liste geholt : ermitteln nxt liste */ THEN CALL FEHLER(DUMMY0,'KS7410E'); END; /*-----------------------------------------------------*/ /* Hinweise abarbeiten m¦glich ? */ /*-----------------------------------------------------*/ IF ( PGMSPA.AKT_HINWEIS > 0 & ^MID_MOD_AENDERUNG() & DC_MID_8.TASTE = K_DATFREI ) THEN DO; $INCR(PGMSPA.AKT_HINWEIS); IF ( PGMSPA.AKT_HINWEIS <= PGMSPA.ANZ_HINWEISE ) THEN KS074DA.BENUMELD = HINWEIS_TAB.TEXT(PGMSPA.AKT_HINWEIS); ELSE CALL MELDEN_BEARBEITET; /*END-IF-hinweis <= Anz*/ RETURN; END; ELSE PGMSPA.AKT_HINWEIS = 0; /* Hinweise zur}cksetzen, normale VA */ /*END-IF-hinweis und DF*/ /*-----------------------------------------------------*/ /* Aufbereiten MID => MOD */ /* -ab hier sind alle Ausgabedaten und Eingabedaten */ /* -im MOD und in der Tabelle ZEILEN_TAB. */ /*-----------------------------------------------------*/ CALL MID_MOD; CALL MOD_ZEILEN_TAB; /* MOD -> ZEILENTAB */ /*-----------------------------------------------------*/ /* Verarbeitung abh{ngig von Taste ausl¦sen */ /*-----------------------------------------------------*/ SELECT ( DC_MID_8.TASTE ); /*------------------------------------------------------------*/ /* ENTER = Verarbeitung komplett */ /*------------------------------------------------------------*/ WHEN(K_DATFREI) DO; IF ( KS074DE.TRAN > ' ' ) THEN CALL TS_SWITCH(KS074DE.TRAN); ELSE CALL VERARB_ENTER; /*END-IF-tran*/ END; /* when k_datfrei */ /*------------------------------------------------------------*/ /* PF05 = Aktualisieren */ /*------------------------------------------------------------*/ WHEN( K_PF_05 ) DO; CALL AKTUALISIERE; END; /*------------------------------------------------------------*/ /* PF03 = R}cksprung ins letzte Funktionsmen} */ /*------------------------------------------------------------*/ WHEN( K_PF_03 ) DO; CALL TS_FKTMENU(); END; /*------------------------------------------------------------*/ /* PF04 = R}ckw{rtsbl{ttern Historisch */ /*------------------------------------------------------------*/ WHEN ( K_PF_04 ) DO; CALL HISTBL_RUECK; END; /*------------------------------------------------------------*/ /* PF06 = Vorw{rtsbl{ttern Historisch */ /*------------------------------------------------------------*/ WHEN ( K_PF_06 ) DO; CALL HISTBL_VOR; END; /*------------------------------------------------------------*/ /* PF07 = R}ckw{rtsbl{ttern */ /*------------------------------------------------------------*/ WHEN( K_PF_07 ) DO; CALL BL_RUECK; END; /*------------------------------------------------------------*/ /* PF08 = Vorw{rtsbl{ttern */ /*------------------------------------------------------------*/ WHEN( K_PF_08 ) DO; CALL BL_VOR; END; /*------------------------------------------------------------*/ /* PF10 = Sprung 'Löschen Schwebe' KO19 */ /*------------------------------------------------------------*/ WHEN( K_PF_10 ) DO; DC_AKTION.NEU_TRANS = 'KO19' ; END; /*------------------------------------------------------------*/ /* PF11 = Sprung KO01 */ /*------------------------------------------------------------*/ WHEN( K_PF_11 ) DO; CALL TS_KO01; DC_AKTION.NEU_MOD = ''; END; /*------------------------------------------------------------*/ /* PF12 = Schrittweises zurück */ /*------------------------------------------------------------*/ WHEN( K_PF_12 ) DO; CALL VERARB_PF12; end; /*------------------------------------------------------------*/ /* SONST = Ungültige PF-Taste */ /*------------------------------------------------------------*/ OTHERWISE CALL FEHLER (DUMMY0, 'KO0320E') ; END; /* select */ END FOLGEAUFRUF; 1/********************************************************************/ /* */ /* R E S T O R E */ /* */ /*------------------------------------------------------------------*/ /* - Aufbau unterbrochenes Bild vom Stack */ /* */ /********************************************************************/ RESTORE: PROC REORDER; IF ( DC_INFO.ST_RESTORE ^= ' ' ) THEN DO; KS074DA = KS074DE, BY NAME; KS074DA.KS074DAL = CSTG( KS074DA ); END; ELSE DO; KS074DA = PGMSPA.MOD_SPA, BY NAME ; KS074DA = KS074DE, BY NAME; KS074DA.KS074DAL = CSTG( KS074DA ); END; /*END-IF-st_restore */ END RESTORE; 1/********************************************************************/ /* */ /* E N D E _ R O U T I N E */ /* */ /*------------------------------------------------------------------*/ /* Verarbeitung zum Ende des Programmes */ /* - Sichern SPA */ /* - Allgemeine MOD Aufbereitungen */ /* - TBKS_PGM_SCHWEBE für Tabelle dyn. Zeilen verwalten */ /* - Dyn. allokierten Speicher verwalten */ /* */ /********************************************************************/ ENDE_ROUTINE: PROC REORDER; /* lokale Variable */ DCL H_RC_SPA BIN FIXED(15); /* Prodedurerumpf -----------------------------------------------*/ H_RC_SPA = 0; /*------------------------------------------------*/ /* Schwebebearbeitung & SPA_Zustand = Bearbeitet */ /* => Update SPA */ /*------------------------------------------------*/ IF ( PGMSPA.SPA_ZUSTAND = 'B' & SCHWEBE_BEARBEITUNG() ) THEN DO; CALL HANDLE_SPA('UPDATE', SPA.PROJEKT.VTRNR, SPA.PROJEKT.BEARB_HISTNR, H_RC_SPA, U_SPA.MANDANT, U_SPA.SPRACHCODE ); IF ( H_RC_SPA > 0 ) THEN CALL FEHLER(DUMMY0,'KV0001E'); /*END-IF-rc>0*/ END; /*END-IF-zustand=B*/ /*------------------------------------------------*/ /* finale MOD-Aufbereitungen */ /*------------------------------------------------*/ IF ( DC_AKTION.NEU_TRANS = ' ' ) THEN DO; /*------------------------------------------------*/ /* => Sichern in PGM_SCHWEBE, wenn keine neue TRAN*/ /*------------------------------------------------*/ /* eventuell Meldungen bearbeiten */ IF ( MELDUNGEN_ID > ' ' ) THEN KS074DA.BENUMELD = LESE_MELDUNG(MELDUNGEN_ID); /*END-IF-meldung_id*/ CALL SET_PFTAST; /* eventuell eigene Anzeigen besetzen */ CALL AKTION_HELP; CALL ANZEIGE_MOD; /* eventuell update im referenzteil gewesen */ CALL PGM_SCHWEBE(K_SCHW_SAVE,k_sn_ZEITAB, P_ZEILEN_TAB,CSTG(ZEILEN_TAB)); CALL PGM_SCHWEBE(K_SCHW_SAVE,k_sn_HINWEIS, P_HINWEIS_TAB,CSTG(HINWEIS_TAB)); CALL PGM_SCHWEBE(K_SCHW_SAVE,k_sn_AUSKUNFT, P_AUSKUNFT_TAB,CSTG(AUSKUNFT_TAB)); /*AEND0002B*/ /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ CALL PGM_SCHWEBE(K_SCHW_SAVE,k_li_variable, P_VARIABLE_TAB,CSTG(VARIABLE_TAB)); /*---neuHSC:Policenauskunft - Ende -------------------------------*/ /*AEND0002E*/ END; ELSE DO; /*------------------------------------------------*/ /* => Löschen der PGM_SCHWEBE, wenn neue TRAN */ /*------------------------------------------------*/ CALL PGM_SCHWEBE(K_SCHW_DEL,0,NULL,0); END; /*END-IF-neu_trans*/ /*------------------------------------------------*/ /* Speicher freigeben */ /*------------------------------------------------*/ CALL FREE_MAIN; END ENDE_ROUTINE; 1/********************************************************************/ /* */ /* V E R A R B _ E N T E R */ /* */ /*------------------------------------------------------------------*/ /* - Verarbeitung, bei Datenfreigabe */ /* - Formale Pr}fung der Eingabefelder (EINGABE_OK) */ /* - Verarbeitung der Aktion (Verarbeitung) */ /* - 'Bearbeitet' melden und n{chste Transaktion ermitteln */ /* */ /********************************************************************/ VERARB_ENTER: PROC REORDER; /*------------------------------------------------------------*/ /* Bei Schwebe VA pr}fen und verarbeiten der Eingaben */ /*------------------------------------------------------------*/ IF ( SCHWEBE_BEARBEITUNG() ) THEN DO; IF ( EINGABE_OK() ) THEN CALL VERARBEITUNG; /*PGMSPA.SPA_ZUSTAND = 'B'; */ /*nur bei update */ END; /* notwendig */ /* Normalfall --------------------------------------------------*/ ELSE DO; IF ( SPA.PROJEKT.VORG_SCHL = K_AUSKUNFT ) THEN DO; IF ( EINGABE_OK() ) THEN DO; /*-----------------------------------------------------*/ /* eigentiche Verarbeitung : ermitteln Folgeliste und */ /* bereitstellen Folgeliste */ /* in AKTLISTE_TAB */ /*-----------------------------------------------------*/ CALL VERARBEITUNG; /*-------------------------------------------------*/ /* MOD aufbauen : Bildschirmfelder f}llen */ /* aus Tabelle AKTLISTE_TAB */ /*-------------------------------------------------*/ CALL FIX_AUFBAU_MOD; /* neu fuer fixe Felder */ CALL AUFBAU_MOD; END; /* PGMSPA.SPA_ZUSTAND = 'B'; */ END; END; /*------------------------------------------------------------*/ /* Wenn SPA_ZUSTAND='B'earbeitet, dann Transssteuer melden */ /* bearbeitet und ermitteln n{chste Transaktion */ /*------------------------------------------------------------*/ IF ( ^B_FEHLER & DC_AKTION.NEU_TRANS = ' ' & PGMSPA.SPA_ZUSTAND = 'B' ) THEN DO; CALL MELDEN_BEARBEITET; END; END VERARB_ENTER; 1/********************************************************************/ /* */ /* A K T U A L I S I E R E ::: nicht relevant */ /* */ /*------------------------------------------------------------------*/ /* - Verarbeitung, bei PF05 'Aktualisieren' */ /* - Formale Prüfung der Eingabefelder (EINGABE_OK) */ /* - Verarbeitung der Aktion (Verarbeitung) */ /* */ /********************************************************************/ AKTUALISIERE: PROC REORDER; /*------------------------------------------------------------*/ /* Normale Verarbeitung bei Aktualisierung */ /*------------------------------------------------------------*/ /* IF ( SCHWEBE_BEARBEITUNG() ) THEN DO; IF ( EINGABE_OK() ) THEN CALL VERARBEITUNG; END; ELSE CALL FEHLER(DUMMY0,'KO0320E'); */ /*-----------------------------------------------------*/ /* Wenn SPA.Status=Bearbeitet, dann 1. Hinweis anzeigen*/ /*-----------------------------------------------------*/ /* IF ( PGMSPA.SPA_ZUSTAND = 'B' & PGMSPA.ANZ_HINWEISE > 0 ) THEN DO; PGMSPA.AKT_HINWEIS = 1; KS074DA.BENUMELD = HINWEIS_TAB.TEXT(1); END; */ END AKTUALISIERE; 1/********************************************************************/ /* */ /* H I S T B L _ R U E C K */ /* */ /*------------------------------------------------------------------*/ /* - Historisches Rückwärtsblättern via KOPFDATEN() */ /* - Aufbau des MOD komplett */ /* - Fehlermeldung, falls nicht möglich */ /* */ /********************************************************************/ HISTBL_RUECK: PROC REORDER; /*---Rumpf -------------------------------------------------------*/ /* Blaettern ist immer moeglich : es wird immer neu gelesen und */ /* die Masken/Listen aufgebaut : Beginn mit Liste VTROBJ */ /*----------------------------------------------------------------*/ /*----------------------------------*/ /* blaettern erlaubt ? */ /*----------------------------------*/ IF ( PGMSPA.HISTNR_NEU > 1 ) /* & (pgmspa.akt_liste = pgmspa.histbl_liste) */ THEN DO; /*----------------------------------*/ /* neue Histnr ermitteln */ /*----------------------------------*/ IF ( KOPFDATEN(K_HIST_RUECK) ) THEN DO; /*-----------------------------------------------------*/ /* eigentiche Verarbeitung : ermitteln Folgeliste und */ /* bereitstellen Folgeliste */ /* in AKTLISTE_TAB */ /*-----------------------------------------------------*/ CALL VERARBEITUNG; CALL ERSTES_OBJEKTAUSWAEHLEN; /* AEND004 */ /*-------------------------------------------------*/ /* MOD aufbauen : Bildschirmfelder f}llen */ /* aus Tabelle AKTLISTE_TAB */ /*-------------------------------------------------*/ CALL FIX_AUFBAU_MOD; /* neu fuer fixe Felder */ CALL AUFBAU_MOD; END; /*----------------------------------*/ /* Fehlerfaelle */ /*----------------------------------*/ ELSE do; CALL FEHLER(DUMMY0,'KS7406E'); END; END; ELSE DO; /* hist. blaettern auf dieser maske nicht moegich */ CALL FEHLER(DUMMY0, 'KO0323E'); END; END HISTBL_RUECK; 1/********************************************************************/ /* */ /* H I S T B L _ V O R */ /* */ /*------------------------------------------------------------------*/ /* - Historisches Vorwärtsblättern via KOPFDATEN() */ /* - Aufbau des MOD komplett */ /* - Fehlermeldung, falls nicht möglich */ /* */ /********************************************************************/ HISTBL_VOR: PROC REORDER; /*---Rumpf -------------------------------------------------------*/ /* Blaettern ist immer moeglich : es wird immer neu gelesen und */ /* die Masken/Listen aufgebaut : Beginn mit liste VTROBJ */ /*---Rumpf -------------------------------------------------------*/ IF ( PGMSPA.HISTNR_NEU ^= SPA.SCHW_HISTNR & PGMSPA.HISTNR_NEU ^= 0 ) /* & (pgmspa.akt_liste = pgmspa.histbl_liste) */ THEN DO; IF ( KOPFDATEN(K_HIST_VOR) ) THEN DO; /*-----------------------------------------------------*/ /* eigentiche Verarbeitung : ermitteln Folgeliste und */ /* bereitstellen Folgeliste */ /* in AKTLISTE_TAB */ /*-----------------------------------------------------*/ CALL VERARBEITUNG; CALL ERSTES_OBJEKTAUSWAEHLEN; /* AEND004 */ /*-------------------------------------------------*/ /* MOD aufbauen : Bildschirmfelder f}llen */ /* aus Tabelle AKTLISTE_TAB */ /*-------------------------------------------------*/ CALL FIX_AUFBAU_MOD; /* neu fuer fixe Felder */ CALL AUFBAU_MOD; END; /*----------------------------------*/ /* Fehlerfaelle */ /*----------------------------------*/ ELSE DO; CALL FEHLER(DUMMY0,'KS7410E'); END; END; ELSE DO; /* kein blaettern */ CALL FEHLER (DUMMY0, 'KO0324E') ; END; END HISTBL_VOR; 1/********************************************************************/ /* */ /* B L _ R U E C K */ /* */ /*------------------------------------------------------------------*/ /* - Dynamische Zeilen eine Seite zurückblättern */ /* - MOD der Zeilen wird neu aufgebaut */ /* - Fehlermeldung, falls nicht möglich */ /* */ /********************************************************************/ BL_RUECK: PROC REORDER; /*---Rumpf -------------------------------------------------------*/ PGMSPA.AKT_SEITE = PGMSPA.AKT_SEITE - 1; IF ( PGMSPA.AKT_SEITE <= 0 ) THEN DO; PGMSPA.AKT_SEITE = 1; CALL FEHLER(DUMMY0,'KO0380W'); END; ELSE PGMSPA.PF12_STACK.ZEIGER = UPD_PF12_STACK_SEITE(); CALL ZEILEN_TAB_MOD; CALL ATTRIBUTE; END BL_RUECK; 1/********************************************************************/ /* */ /* B L _ V O R */ /* */ /*------------------------------------------------------------------*/ /* - Dynamische Zeilen eine Seite vorblättern */ /* - MOD der Zeilen wird neu aufgebaut */ /* - Fehlermeldung, falls nicht möglich */ /* */ /********************************************************************/ BL_VOR: PROC REORDER; /*---Rumpf -------------------------------------------------------*/ PGMSPA.AKT_SEITE = PGMSPA.AKT_SEITE + 1; IF ( (PGMSPA.AKT_SEITE-1) * $ZEILEN_SEITE >= PGMSPA.ANZ_ZEILEN ) THEN DO; PGMSPA.AKT_SEITE = PGMSPA.AKT_SEITE - 1; CALL FEHLER(DUMMY0,'KO0501W'); END; ELSE PGMSPA.PF12_STACK.ZEIGER = UPD_PF12_STACK_SEITE(); CALL ZEILEN_TAB_MOD; CALL ATTRIBUTE; END BL_VOR; 1/********************************************************************/ /* */ /* V E R A R B _ P F 1 2 */ /* */ /*------------------------------------------------------------------*/ /* Funktion, um auf die vorige Liste zurueckzukehren */ /* - ermitteln vorige startposition(Zeile) ueber STACK_PF12 */ /* - bei Zeile = 0 ===> vorige Transaktion anspringen */ /* - bei Zeile <>0 ===> Liste neu aufbauen aus der AUSKUNFT_TAB */ /* - Fehlermeldung, falls keine Ermittlung einer Folgeliste mgl war */ /* */ /*------------------------------------------------------------------*/ /* wird waehrend Verarbeitung in Folgeliste, Ermi_Fol durchgef}hrt */ /********************************************************************/ VERARB_PF12: PROC REORDER; /*-----------------------------------------------------*/ /* eigentiche Verarbeitung : ermitteln Folgeliste und */ /* bereitstellen Folgeliste */ /* in AKTLISTE_TAB */ /*-----------------------------------------------------*/ CALL VERARBEITUNG; /*-----------------------------------------------------*/ /* sonderbehandlung : vertragsauswahl, objektkonsistenz*/ /*-----------------------------------------------------*/ SELECT (PGMSPA.AKT_LISTE); WHEN (K_LI_VTRAUS) DO; /* bei Liste Vertragsauswahl bleiben nur die Policen felder */ /* gefuellt. Vertragsabhaengige felder werden zuruecgesetzt */ CALL INIT_ERSTAUSWAHL; PGMSPA.AKT_SEITE = 1; END; OTHERWISE DO; /* aktuelle position in der Zeilentab wieder holen als akt_seite */ /* zum Beispiel dasselbe Objekt wieder anzeigen, vom dem aus in */ /* die Folgeliste gesprungen wurde */ PGMSPA.AKT_SEITE = PGMSPA.PF12_AKT_SEITE; END; END; /*-------------------------------------------------*/ /* MOD aufbauen : Bildschirmfelder f}llen */ /* aus Tabelle AKTLISTE_TAB */ /*-------------------------------------------------*/ CALL FIX_AUFBAU_MOD; /* neu fuer fixe Felder */ CALL AUFBAU_MOD; END VERARB_PF12; 1/********************************************************************/ /* */ /* E I N G A B E _ O K */ /* */ /*------------------------------------------------------------------*/ /* - Formale Pr}fungen der Eingabedaten */ /* */ /********************************************************************/ EINGABE_OK: PROC RETURNS ( BIT(1) ) REORDER; /* RETURN_PARAMETER */ DCL RESULT BIT(1); /*--lokale variable-----------*/ DCL I BIN FIXED(15); DCL REF_IND BIN FIXED(15); DCL B_EIN CHAR(1); /* Rumpf Beginn Eingabe_ok ------------------------------------------*/ RESULT = K_TRUE; B_EIN = K_NEIN; /* $$$ Formale Pr}fung der Eingaben */ /*------------------------------------------------*/ /* Standard_Eingabefelder pruefen */ /*------------------------------------------------*/ IF ( KS074DE.ORDBGR > ' ' ) THEN DO; CALL FEHLER(KS074DA.ORDBGR0,'KO0320E'); RESULT = K_FALSE ; END; IF ( KS074DE.CMD > ' ' ) THEN DO; CALL FEHLER(KS074DA.CMD0,'KO0320E'); RESULT = K_FALSE ; END; /* $$$ (}ber die Funktion PRUEF_FELD) */ /*------------------------------------------------*/ /* Eingaben in Aktionsfelder pruefen */ /*------------------------------------------------*/ DO I = 1 TO PGMSPA.ANZ_ZEILEN WHILE ( RESULT = K_TRUE ); IF (ZEILEN_TAB.AKTION(I) = ' ') THEN DO; /*----------------------------------*/ /* Keine Eingabe ausser Tasten */ /*----------------------------------*/ RESULT = K_TRUE; END; ELSE DO; /*----------------------------------*/ /* ausser 'X' auch 'L' zulassen */ /*----------------------------------*/ IF (ZEILEN_TAB.AKTION(I) = K_AKT_L) THEN ZEILEN_TAB.AKTION(I) = K_AKT_X; IF ( ^PRUEF_FELD(ZEILEN_TAB.AKTION0(I), K_KANNFELD, K_ALPHA, K_LINKS) ) THEN DO; /*----------------------------------*/ /* Pruefung Domain fehlerhaft */ /*----------------------------------*/ RESULT = K_FALSE; /* Falsche Zeichen eingegeben : Format */ CALL FEHLER(DUMMY0,'KS7407E'); END; /*-----------------------------------*/ /* Pruefung der eingegebenen Zeichen */ /*-----------------------------------*/ ELSE DO; IF ( ^IN_REF(ZEILEN_TAB.AKTION(I),I,REF_IND,B_EIN) ) THEN DO; /* gueltiges Aktionszeichen, aber in der gewaehlten */ /* Zeile nicht moeglich, weil Daten fehlen */ IF ZEILEN_TAB.AKTION(I) = K_AKT_L ! ZEILEN_TAB.AKTION(I) = K_AKT_X ! ZEILEN_TAB.AKTION(I) = K_AKT_B ! ZEILEN_TAB.AKTION(I) = K_AKT_T ! ZEILEN_TAB.AKTION(I) = K_AKT_I THEN DO; /*----------------------------------*/ /* Pruefung gueltige Aktion fehlerh.*/ /*----------------------------------*/ RESULT = K_FALSE; /* Falsche Zeichen eingegeben : Vorgaben */ CALL FEHLER(DUMMY0,'KS7405E'); END; ELSE DO; /*----------------------------------*/ /* Pruefung gueltige Aktion fehlerh.*/ /*----------------------------------*/ RESULT = K_FALSE; /* Falsche Zeichen eingegeben : Vorgaben */ CALL FEHLER(DUMMY0,'KS7408E'); END; END; ELSE DO; /*----------------------------------*/ /* alle Eingaben korrekt */ /*----------------------------------*/ RESULT = K_TRUE; PGMSPA.B_EINGABE = B_EIN; END; /* Zeichen in der Referenztabelle */ END; /* gueltige Zeichen */ END; /* Eingabe in Zeilevorhanden */ END; /* schleife Eingabezeilen */ RETURN(RESULT); END EINGABE_OK; 1/********************************************************************/ /* */ /* V E R A R B E I T U N G */ /* */ /*------------------------------------------------------------------*/ /* Verarbeitung der Eingabedaten */ /* - ermitteln der Zeilennummer (in AUSKUNFT_TAB) als Beginn einer */ /* neuen Liste aus den Referenzdaten abh. vom Aktionscode */ /* - Zeilen der neuen Liste in den Zwischenspeicher AKTLISTE holen */ /* - event. die Kopfdaten anpassen, weil sich HISTNR oder VTRNR */ /* geaendert hat (hist.-Blaettern, Vertragsauswahl) */ /* */ /********************************************************************/ VERARBEITUNG: PROC REORDER; DCL FOL_ZEI BIN FIXED(15); /* Rumpf Beginn Eingabe_ok ------------------------------------------*/ FOL_ZEI = -1; PGMSPA.B_KOPF_KO = K_NEIN; /*-----------------------------------------------------*/ /* ermittle_Folgeliste */ /*-----------------------------------------------------*/ FOL_ZEI = FOLGELISTE(); IF FOL_ZEI < 0 THEN DO; /* keine Folgeliste zu ermitteln / vorhanden */ CALL FEHLER(DUMMY0,'KS7404E'); END; /*----------------------------------*/ /* Bearbeitung ermittelte Folgeliste*/ /*----------------------------------*/ ELSE DO; SELECT (FOL_ZEI); WHEN (0) DO; CALL TS_RUECK(); END; /*----------------------------------*/ /* Bearbeitung ermittelte Folgeliste*/ /*----------------------------------*/ OTHERWISE DO; IF PGMSPA.NEUAUFBAU = K_JA THEN DO; /*------------------------------------------------*/ /* Aufbau der neuen AUSKUNFT_TAB ueber SP MKS1315 */ /*------------------------------------------------*/ CALL NEUAUFBAU_PI_AUSKUNFT; END; /* else keine neue listen aufgebaut */ IF PGMSPA.NEUHOLEN = K_JA THEN DO; /*----------------------------------------------*/ /* Aufbau der ersten Liste : AKTLISTE_TAB */ /*----------------------------------------------*/ CALL NEUHOLEN_LISTE; END; /* else keine neue listen geholt */ END; /* otherwise */ END; /* select */ /*-----------------------------------------------------*/ /* Aufbereiten Kopfdaten - Kompass Standardteile */ /*-----------------------------------------------------*/ /* wegen eventuell neu ausgesuchtem vertrag */ IF ^B_FEHLER THEN DO; IF ( PGMSPA.B_KOPF_KO = K_JA ) THEN DO; IF ( ^KOPFDATEN(K_HIST_DIREKT) ) THEN DO; SPA.FEHL_INFO.RETCODE = 1; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Fehlerhafter '!! ' Aufruf : Routine KOPFDATEN '; XKO0997.ANW_FEHLER(2) = 'lesen direkt mit HISTNR_NEU = '!! PGMSPA.HISTNR_NEU; CALL ABBRUCH; END; /* Fehler bei UP-Kopfdaten */ ELSE DO; PGMSPA.NXT_HISTNR = PGMSPA.HISTNR_NEU; CALL AKTUAL_HISTNR; END; END; /* UP-Kopfdaten aufrufen */ ELSE DO; IF PGMSPA.ANZ_VERTRAEGE = 1 THEN DO; SPA.FEHL_INFO.RETCODE = 2; XKO0997.ANW_FEHLER(1) = 'Kopfdaten nicht aufbereitbar !'; XKO0997.ANW_FEHLER(2) = 'VSNR = '!!SPA.PROJEKT.VSNR!! ' VTRNR = '!!PGMSPA.AKT_VERTRAG!! ' HISTNR = '!!PGMSPA.AKT_HISTNR; /* CALL ABBRUCH; */ END; /* ein Vertrag aber keine Kopfdaten aufrufen : # */ END; /* keine Kopfaten ermitteln */ END; /* B_FEHLER */ END; END VERARBEITUNG; 1/********************************************************************/ /* */ /* F O L G E L I S T E */ /* */ /*------------------------------------------------------------------*/ /* SUCHEN DER NEUEN LISTE AUFGRUND DER EINGABE IN DEN REFERENZEN */ /* */ /********************************************************************/ FOLGELISTE: PROC RETURNS(BIN FIXED(15)) REORDER; /* in / out */ /* RETURN */ DCL FOL_ZEI BIN FIXED(15); /* lokale variable */ DCL VTRNR DEC FIXED(15,0); DCL HISTNR DEC FIXED(05,0); /* rumpf ---------------------------------------------------------*/ FOL_ZEI = -1; /*--------------------------------------------------------------*/ /* Ermitteln der Aufsetz-Zeile der Folgeliste aus der Listen- */ /* referenz und Rueckgabe der naechsten steuernden Daten */ /*--------------------------------------------------------------*/ FOL_ZEI = ERMI_FOL(PGMSPA.NXT_VERTRAG,PGMSPA.NXT_HISTNR, PGMSPA.NXT_LISTE); IF FOL_ZEI < 0 THEN DO; SPA.FEHL_INFO.RETCODE = 7404; XKO0997.ANW_FEHLER(1) = 'KEINE LISTE BEI FOLGEAUFRUF !'; CALL ABBRUCH; END; /*--------------------------------------------------------------*/ /* Aktualisieren der aktuell anzuzeigenden neuen Listenparameter*/ /* mit diesen werden die Hol-Aktionen durchgefuehrt */ /*--------------------------------------------------------------*/ IF PGMSPA.NXT_VERTRAG ^= PGMSPA.AKT_VERTRAG THEN DO; /* neuer Vertrag ermittelt: also alle Listen neu aufbauen */ /* ueber Stored-Procedure-Aufruf */ /*----------------------------------------------------------*/ PGMSPA.NEUAUFBAU = K_JA; CALL AKTUAL_VERTRAG; CALL AKTUAL_HISTNR; CALL AKTUAL_LISTE; PGMSPA.NXT_PI_ZEILE = FOL_ZEI; CALL AKTUAL_PI_ZEILE; /* wichtig fuer Abspeicherung in Schwebe */ /*----------------------------------------------------------*/ SPA.PROJEKT.VTRNR = PGMSPA.AKT_VERTRAG; END; ELSE DO; /* Bei historisch blaettern ist neue Historien erkannt ; */ /* also alle Listen neu aufbauen: Stored-Procedure-Aufruf */ /*----------------------------------------------------------*/ IF PGMSPA.NXT_HISTNR ^= PGMSPA.AKT_HISTNR THEN DO; PGMSPA.NEUAUFBAU = K_JA; CALL AKTUAL_HISTNR; CALL AKTUAL_LISTE; PGMSPA.NXT_PI_ZEILE = FOL_ZEI; CALL AKTUAL_PI_ZEILE; END; ELSE DO; /* nur neue Liste in derselben Konstelation VTRNR,HISTNR */ /*----------------------------------------------------------*/ PGMSPA.NEUAUFBAU = K_NEIN; IF FOL_ZEI ^= PGMSPA.AKT_PI_ZEILE THEN DO; PGMSPA.NEUHOLEN = K_JA; CALL AKTUAL_LISTE; PGMSPA.NXT_PI_ZEILE = FOL_ZEI; CALL AKTUAL_PI_ZEILE; END; ELSE DO; /* keine Aenderung der Liste erkannt */ /*----------------------------------------------------------*/ PGMSPA.NEUHOLEN = K_NEIN; END; END; END; RETURN(FOL_ZEI); END FOLGELISTE; 1/********************************************************************/ /* */ /* E R S T L I S T E */ /* */ /*------------------------------------------------------------------*/ /* - Erstmaske ueber mks1314 */ /* - dann Folgeverarbeitung */ /* */ /********************************************************************/ ERSTLISTE: PROC REORDER; /*---------------------------------------------------------------*/ /* Daten holen fuer die Auswahlmaske VTRAUS */ /*---------------------------------------------------------------*/ PGMSPA.ANZ_VERTRAEGE = ERSTMASKE(SPA.VSNR, K_LI_VTRAUS); /*---------------------------------------------------------------*/ /* wenn zur vsnr mindestens ein vertrag gefunden */ /*---------------------------------------------------------------*/ IF PGMSPA.ANZ_VERTRAEGE >= 1 THEN DO; /* Tabelle Aktliste mit Listeninhalt fuellen */ /*-------------------------------------------------------------*/ PGMSPA.ANZ_ZEILEN_AK = HOLE_AKT_LISTE(PGMSPA.AKT_PI_ZEILE); /* da Verarbeitung auf der zeilen_tab arbeitet, diese fuellen */ /*-------------------------------------------------------------*/ CALL LESE_ZEILEN_TAB; /* Eingabe simulieren */ /*-------------------------------------------------------------*/ IF PGMSPA.ANZ_ZEILEN = 1 THEN DO; ZEILEN_TAB.AKTION(1)= 'X'; PGMSPA.B_EINGABE = K_JA; END; /* normale Verarbeitung zur ermittlung der Folgeliste rufen */ /*-------------------------------------------------------------*/ /* CALL VERARBEITUNG; passiert jetzt in dunkeldurchlauf */ /* B_Eingabe = JA ==> Dunkeldurchlauf */ END; ELSE DO; /* kein vertrag gefunden */ CALL FEHLER(DUMMY0,'KS7401E'); END; END ERSTLISTE; 1/*** AEND004 - GVLK *************************************************/ */ /* */ /* E R S T E S _ O B J E K T A U S W A E H L E N */ /* */ /*------------------------------------------------------------------*/ /* BEI GVL-KARSTADT SOLL IMMER DAS ERSTE OBJEKT "AUFGEKLAPPT" */ /* WERDEN. */ /********************************************************************/ ERSTES_OBJEKTAUSWAEHLEN: PROC REORDER; /* EINGABE SIMULIEREN */ IF SPA.PROJEKT.ZWEIG = '3610' THEN DO; PGMSPA.ANZ_ZEILEN_AK = HOLE_AKT_LISTE(PGMSPA.AKT_PI_ZEILE); CALL LESE_ZEILEN_TAB; ZEILEN_TAB.AKTION(2) = 'X'; PGMSPA.B_EINGABE = K_JA; CALL VERARB_ENTER; END; END ERSTES_OBJEKTAUSWAEHLEN; 1/********************************************************************/ /* */ /* K O P F D A T E N */ /* */ /*------------------------------------------------------------------*/ /* Ermitteln der Standardkopfdaten einer Maske via MKO3066 */ /*------------------------------------------------------------------*/ /* EINGABE: FKT = Funktion K_... */ /* RETURN: BIT(1) = K_TRUE : Blättern möglich und ausgeführt */ /* = K_FALSE : Blättern nicht möglich */ /* */ /********************************************************************/ KOPFDATEN: PROC ( FKT ) RETURNS( BIT(1) ) REORDER; DCL FKT CHAR(01); /*-----------------------------------------------------------*/ /* Eingabeparameter MKO3066 */ /*-----------------------------------------------------------*/ XKO3066.FUNKTION = FKT; XKO3066E.P_SPA = ADDR(SPA); XKO3066.MANDANT = U_SPA.MANDANT ; XKO3066.SPRACHCODE = U_SPA.SPRACHCODE; IF ( DC_INFO.ERSTAUFRUF = K_JA ) THEN DO; IF PGMSPA.HISTNR_NEU = 0 THEN DO; XKO3066E.A_HISTN = 0; XKO3066E.A_AENDDT = ' '; END; ELSE DO; XKO3066E.A_HISTN = PGMSPA.HISTNR_NEU ; XKO3066E.A_AENDDT = PGMSPA.AENDDT_NEU ; END; END; ELSE DO; XKO3066E.A_HISTN = PGMSPA.HISTNR_NEU ; XKO3066E.A_AENDDT = PGMSPA.AENDDT_NEU ; END; /*-----------------------------------------------------------*/ /* Aufruf MKO3066 */ /*-----------------------------------------------------------*/ $UCALL('MKO3066'); SELECT(XKO3066.RETCODE); WHEN(0); WHEN(1) DO; /* => Bl{ttern nicht m¦glich */ CALL FEHLER (DUMMY0, XKO3066.MELD_ID ); RETURN(K_FALSE); END; OTHERWISE $UPRO_ABBRUCH(XKO3066.FMODUL, XKO3066.FMODUL_RETCODE, XKO3066.SQLCALLNR, 'MKO3066 / RC = ' !! XKO3066.RETCODE); END; /*-----------------------------------------------------------*/ /* F}llen MOD: allg. vertrags-daten */ /*-----------------------------------------------------------*/ /* nicht hier, weil in kundendaten ermittelt und ausgegeben */ KS074DA.VSNR = XKO3066A.VSNR ; KS074DA.PERSNRN = XKO3066A.PERSNRN; KS074DA.HISTNRN = XKO3066A.HISTN ; KS074DA.AENDDTN = XKO3066A.AENDN ; KS074DA.BEARDTN = XKO3066A.BEARBN ; KS074DA.BEARBST = XKO3066A.ASTATN ; /*-----------------------------------------------------------*/ /* F}llen PGMSPA */ /*-----------------------------------------------------------*/ PGMSPA.HISTNR_NEU = XKO3066A.D_HISTN; PGMSPA.HISTNR_ALT = XKO3066A.D_HISTA; /*-----------------------------------------------------------*/ RETURN(K_TRUE); END KOPFDATEN; 1/********************************************************************/ /* */ /* A U F B A U _ M O D */ /* */ /*------------------------------------------------------------------*/ /* MOD aufbauen, ohne einmalige Aktionen wie Kopfdaten usw. */ /* */ /********************************************************************/ AUFBAU_MOD: PROC REORDER; /* $$$ CALL LESE_ZEILEN_TAB; */ CALL LESE_ZEILEN_TAB; CALL ZEILEN_TAB_MOD; CALL ATTRIBUTE; END AUFBAU_MOD; /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ 1/********************************************************************/ /* */ /* F I X _ A U F B A U _ M O D */ /* */ /*------------------------------------------------------------------*/ /* MOD aufbauen, ohne einmalige Aktionen wie Kopfdaten usw. */ /* */ /********************************************************************/ FIX_AUFBAU_MOD: PROC REORDER; DCL K BIN FIXED(15); DCL INDEX BIN FIXED(15); KS074DA.KDNRFELD = 'KQV-KD '; KS074DA.VBWEG = ''; KS074DA.TARIFG = ''; KS074DA.VARTEXT = ''; /* AEND003 */ KS074DA.VARWERT = ''; /* AEND003 */ DO K = 1 to TAB_Zusatz_Infos.Anzahl_Felder; INDEX = 0; INDEX = VarTab_has(TAB_Zusatz_Infos.Eintrag(k).BS_Feld_Name); IF (INDEX > 0 ) THEN DO; STRING(Variable_Zeile) = Variable_Tab.Eintrag.Text(INDEX); select(Variable_Zeile.Var_Nummer); when ('0001') KS074DA.VBWEG = Variable_Zeile.Var_Wert; when ('0002') KS074DA.TARIFG = Variable_Zeile.Var_Wert; when ('0003') /* AEND003 */ KS074DA.VARTEXT = Variable_Zeile.Var_Wert; when ('0004') /* AEND003 */ KS074DA.VARWERT = Variable_Zeile.Var_Wert; other; end; END; END; END FIX_AUFBAU_MOD; 1/********************************************************************/ /* */ /* A N Z E I G E _ M O D */ /* */ /*------------------------------------------------------------------*/ /* - Setzen der Felder der Neuhistorie auf Blank, falls Neuwert */ /* gleich Altwert (inkl. dyn. angezeigte Zeilen) */ /* - Sichern MOD in PGMSPA und MID */ /* */ /********************************************************************/ ANZEIGE_MOD: PROC REORDER ; DCL BEGINN BIN FIXED(15); BEGINN = (PGMSPA.AKT_SEITE-1) * $ZEILEN_SEITE; /*-----------------------------------------------------*/ /* MOD in PGMSPA sichern */ /*-----------------------------------------------------*/ PGMSPA.MOD_SPA = KS074DA, BY NAME ; /*-----------------------------------------------------*/ /* MOD in MID kopieren (für MEK) */ /*-----------------------------------------------------*/ KS074DE = KS074DA, BY NAME ; END ANZEIGE_MOD; 1/********************************************************************/ /* */ /* A T T R I B U T E */ /* */ /*------------------------------------------------------------------*/ /* - Setzen der Bildschirmattribute gemäß Vorgang */ /* */ /********************************************************************/ ATTRIBUTE: PROC REORDER ; DCL BEGINN BIN FIXED(15); DCL I BIN FIXED(15); BEGINN = (PGMSPA.AKT_SEITE-1) * $ZEILEN_SEITE; /*---------------------------------------------------------------*/ /* Cursor auf erstes Eingabefeld setzen : hier Vertragsauswahl */ /*---------------------------------------------------------------*/ I = BEGINN + 1; ZEILEN_TAB.AKTIONA(I) = ZEILEN_TAB.AKTIONA(I) ! ATTR_CURSOR; ZEILEN_TAB.AKTIONA(I+1) = ZEILEN_TAB.AKTIONA(I+1) ! ATTR_CURSOR; KS074DA.AKTIONA(1) = KS074DA.AKTIONA(1) ! ATTR_CURSOR; KS074DA.AKTIONA(1+1) = KS074DA.AKTIONA(1+1) ! ATTR_CURSOR; END ATTRIBUTE; 1/********************************************************************/ /* */ /* S E T _ P F T A S T */ /* */ /*------------------------------------------------------------------*/ /* - Setzen der letzetn BS-Zeile abh. von liste und Vorgang */ /* }ber auslesen von PGMTEXT */ /* */ /********************************************************************/ SET_PFTAST: PROC REORDER; DCL VONZEIL_PIC PIC'ZZ9' BASED(ADDR(KS074DA.VONZEIL)); DCL BISZEIL_PIC PIC'ZZ9' BASED(ADDR(KS074DA.BISZEIL)); DCL ANZZEIL_PIC PIC'ZZ9' BASED(ADDR(KS074DA.ANZZEIL)); DCL TEXTNR BIN FIXED(15); DCL (VONZEIL,BISZEIL,ANZZEIL) BIN fixed(15); VONZEIL = VONZEIL_PIC; BISZEIL = BISZEIL_PIC; ANZZEIL = ANZZEIL_PIC; SELECT; WHEN ( VONZEIL = 1 & ANZZEIL <= BISZEIL ) TEXTNR = 4; /* kein F7/F8 */ WHEN ( VONZEIL = 1 & ANZZEIL > BISZEIL ) TEXTNR = 4; /* nur F8 */ WHEN ( VONZEIL > 1 & ANZZEIL > BISZEIL ) TEXTNR = 4; /* F7 und F8 */ WHEN ( VONZEIL > 1 & ANZZEIL <= BISZEIL ) TEXTNR = 4; /* nur F7 */ OTHERWISE TEXTNR = 4; /* F7 und F8 */ END; /* select */ KS074DA.PFTAST = LESE_PGMTEXT(TEXTNR); END SET_PFTAST; 1/********************************************************************/ /* */ /* A K T _ H E L P */ /* */ /*------------------------------------------------------------------*/ /* - Setzen der BS-Zeile fuer die moeglichen Aktionen in der Liste */ /* */ /********************************************************************/ AKTION_HELP: PROC REORDER; SELECT (PGMSPA.AKT_LISTE); WHEN (K_LI_VTRAUS) KS074DA.ACTHELP = LESE_PGMTEXT(3); OTHERWISE KS074DA.ACTHELP = LESE_PGMTEXT(2); END; END AKTION_HELP; 1/********************************************************************/ /* */ /* M I D _ M O D */ /* */ /*------------------------------------------------------------------*/ /* - Baut aus gesicherten MOD und MID den neuen MOD auf. */ /* Alle weitere Verarbeitung/Prüfung basiert auf diesem MOD */ /* */ /********************************************************************/ MID_MOD: PROC REORDER; DCL I BIN FIXED(15); /*-----------------------------------------------------------*/ /* ]bertragen gesicherten MOD in MOD */ /*-----------------------------------------------------------*/ KS074DA = PGMSPA.MOD_SPA, BY NAME; KS074DA.BENUMELD = ' '; /*-----------------------------------------------------------*/ /* ]bertragen der MID-Felder in MOD, ggf. in Gro~buchstaben */ /*-----------------------------------------------------------*/ KS074DA.TRAN = UPPER(KS074DE.TRAN); KS074DA.ORDBGR = UPPER(KS074DE.ORDBGR); KS074DA.CMD = UPPER(KS074DE.CMD); /* $$$ weitere MID-Felder */ DO I = 1 TO $ZEILEN_SEITE; /* $$$ alle MID-Felder der dyn. Zeilen */ KS074DA.AKTION(I) = UPPER(KS074DE.AKTION(I)); END; END MID_MOD; 1/********************************************************************/ /* */ /* M I D _ M O D _ A E N D E R U N G */ /* */ /*------------------------------------------------------------------*/ /* - Prüft, ob Aenderungen gemacht wurden */ /* RETURN: K_TRUE : Es wurden Eingabe gemacht */ /* K_FALSE : Es wurde keine Eingabe gemacht */ /* */ /********************************************************************/ MID_MOD_AENDERUNG: PROC RETURNS ( BIT(1) ) REORDER; DCL RESULT BIT(1); RETURN(K_FALSE); END MID_MOD_AENDERUNG; 1/********************************************************************/ /* */ /* L E S E _ Z E I L E N _ T A B */ /* */ /*------------------------------------------------------------------*/ /* Ermittelt alle anzuzeigenden Zeilen und stellt diese in */ /* ZEILEN_TAB ab. */ /* */ /********************************************************************/ LESE_ZEILEN_TAB: PROC REORDER; DCL I BIN FIXED(15); DCL J BIN FIXED(15); ZEILEN_TAB = ''; IF AKTLISTE_TAB.ANZAHL_ZEILEN > 0 THEN DO; DO I = 1 TO AKTLISTE_TAB.ANZAHL_ZEILEN; ZEILEN_TAB.TEXT(I) = AKTLISTE_TAB.EINTRAG.TEXT(I); ZEILEN_TAB.ZNR (I) = AKTLISTE_TAB.EINTRAG.ZNR (I); ZEILEN_TAB.ONR (I) = AKTLISTE_TAB.EINTRAG.ONR (I); ZEILEN_TAB.VTRNR (I) = AKTLISTE_TAB.EINTRAG.VTRNR (I); DO J = 1 TO $MAX_REF_F; ZEILEN_TAB.REF_TAB.AKT_CODE(I,J) = AKTLISTE_TAB.REF_TAB.AKT_CODE(I,J); ZEILEN_TAB.REF_TAB.LIS_ZEINR(I,J) = AKTLISTE_TAB.REF_TAB.LIS_ZEINR(I,J); END; IF ZEILEN_TAB.TEXT(I) = ' ' THEN DO; ZEILEN_TAB.AKTION(I) = ' '; ZEILEN_TAB.AKTIONA(I) = DALOES; END; else do; IF (REF_LEER(I)) THEN DO; IF ZEILEN_TAB.VTRNR (I) = 0 THEN DO; ZEILEN_TAB.AKTION(I) = ' '; ZEILEN_TAB.AKTIONA(I) = DALOES; END; END; END; END; PGMSPA.ANZ_ZEILEN = AKTLISTE_TAB.ANZAHL_ZEILEN; END; ELSE DO; KS074DA.BENUMELD = 'Keine Informationen zum Vertrag vorhanden.' !! 'VTR ev. in Neuanlage'; /* XKO0997.ANW_FEHLER(1) = 'auskunft nicht gefuellt '; CALL ABBRUCH; */ END; END LESE_ZEILEN_TAB; 1/********************************************************************/ /* */ /* Z E I L E N _ T A B _ M O D */ /* */ /*------------------------------------------------------------------*/ /* - Kopiert Zeilentabelleneinträge in den MOD (aktueller Zustand) */ /* (nur sichtbarer Teil) */ /* */ /********************************************************************/ ZEILEN_TAB_MOD: PROC REORDER; DCL BEGINN BIN FIXED(15), I BIN FIXED(15), J BIN FIXED(15); DCL VONZEIL_PIC PIC'ZZ9' BASED(ADDR(KS074DA.VONZEIL)); DCL BISZEIL_PIC PIC'ZZ9' BASED(ADDR(KS074DA.BISZEIL)); DCL ANZZEIL_PIC PIC'ZZ9' BASED(ADDR(KS074DA.ANZZEIL)); BEGINN = (PGMSPA.AKT_SEITE-1) * $ZEILEN_SEITE; /*------------------------------*/ /* ]bertragen akt. Seite in MOD */ /*------------------------------*/ DO I = 1 TO $ZEILEN_SEITE WHILE ( BEGINN + I <= PGMSPA.ANZ_ZEILEN ); KS074DA.TAB1(I) = ZEILEN_TAB.EINTRAG(BEGINN+I), BY NAME; END; /*---------------------------------*/ /* Sperren restl. Felder der Seite */ /*---------------------------------*/ DO J = I TO $ZEILEN_SEITE; KS074DA.TAB1.TEXT(J) = ' '; KS074DA.AKTION(J) = ' '; KS074DA.AKTIONA(J) = DALOES; END; /* do j */ /*---------------------------------*/ /* Setzen Info-Felder */ /*---------------------------------*/ /* ks074da.lisname = pgmspa.akt_maske; */ VONZEIL_PIC = ((PGMSPA.AKT_SEITE-1) * $ZEILEN_SEITE) + 1; BISZEIL_PIC = VONZEIL_PIC + $ZEILEN_SEITE - 1; ANZZEIL_PIC = PGMSPA.ANZ_ZEILEN; IF ( BISZEIL_PIC > ANZZEIL_PIC ) THEN BISZEIL_PIC = ANZZEIL_PIC; CALL FUELLE_STAT_OBJ(BEGINN,$ZEILEN_SEITE); CALL FUELLE_STAT_VTR; END ZEILEN_TAB_MOD; 1/********************************************************************/ /* */ /* M O D _ Z E I L E N _ T A B */ /* */ /*------------------------------------------------------------------*/ /* - Kopiert MOD in die entspr. Zeilentabelleneinträge */ /* (nur Eingabefelder) */ /* */ /********************************************************************/ MOD_ZEILEN_TAB: PROC REORDER; DCL BEGINN BIN FIXED(15), I BIN FIXED(15); BEGINN = (PGMSPA.AKT_SEITE-1) * $ZEILEN_SEITE; DO I = 1 TO $ZEILEN_SEITE WHILE ( BEGINN + I <= PGMSPA.ANZ_ZEILEN ); ZEILEN_TAB.EINTRAG(BEGINN+I) = KS074DA.TAB1(I), BY NAME; END; END MOD_ZEILEN_TAB; 1/********************************************************************/ /* */ /* D U N K E L _ D U R C H L A U F */ /* */ /*------------------------------------------------------------------*/ /* - Prüft im Erstaufruf der Transaktion, ob Dunkeldurchlauf */ /* ausgef}hrt wird */ /* */ /********************************************************************/ DUNKEL_DURCHLAUF: PROC RETURNS ( BIT(1) ) REORDER; /* $$$ Prüfung, ob Dunkeldurchlauf */ IF PGMSPA.B_EINGABE = K_JA THEN RETURN(K_TRUE); ELSE RETURN(K_FALSE); END DUNKEL_DURCHLAUF; /********************************************************************/ /* */ /* L E S E _ H I N W E I S E */ /* */ /*------------------------------------------------------------------*/ /* Stellt in die Tabelle HINWEIS_TAB die anzuzeigenden Hinweise ein.*/ /* */ /********************************************************************/ LESE_HINWEISE: PROC REORDER; /* $$$ F}llen der Tabelle HINWEIS_TAB */ /* PGMSPA.ANZ_HINWEISE = Anzahl; */ END LESE_HINWEISE; 1/********************************************************************/ /* */ /* M E L D E N _ B E A R B E I T E T */ /* */ /*------------------------------------------------------------------*/ /* - Prüft, ob noch anzuzeigende Hinweise vorhanden */ /* - Meldet die Transaktion als 'Bearbeitet' und ermittelt nächste */ /* */ /********************************************************************/ MELDEN_BEARBEITET: PROC REORDER; /*--------------------------------------------------------*/ /* Falls Meldung noch nicht angezeigt => Nicht bearbeitet */ /* Oder falls noch Hinweise anzuzeigen sind */ /*--------------------------------------------------------*/ IF ( MELDUNGEN_ID ^= ' ' & ( PGMSPA.ANZ_HINWEISE > 0 ! PGMSPA.AKT_HINWEIS <= PGMSPA.ANZ_HINWEISE ) ) THEN RETURN; /*--------------------------------------------------------*/ /* Melden bearbeitet */ /*--------------------------------------------------------*/ CALL TS_BEARBVOR(K_TS_BEARB,' '); END MELDEN_BEARBEITET; 1/********************************************************************/ /* */ /* S C H W E B E _ B E A R B E I T U N G */ /* */ /*------------------------------------------------------------------*/ /* Gibt zurück, ob auswertbare Eingabe gemacht werden konnten */ /* */ /********************************************************************/ SCHWEBE_BEARBEITUNG: PROC RETURNS ( bit(1) ) REORDER; IF ( SPA.PROJEKT.VORG_SCHL ^= K_AUSKUNFT & PGMSPA.HISTNR_NEU = SPA.SCHW_HISTNR ) THEN RETURN(K_TRUE); ELSE RETURN(K_FALSE); END SCHWEBE_BEARBEITUNG; 1/********************************************************************/ /* */ /* P G M _ S C H W E B E */ /* */ /*------------------------------------------------------------------*/ /* Hülle für MKQ6100 - Verwaltung TBKS_PGM_SCHWEBE */ /* */ /********************************************************************/ PGM_SCHWEBE: PROC ( FKT, AB_LFDNR, BEREICH, LAENGE ) REORDER; DCL FKT CHAR(1), AB_LFDNR BIN FIXED(15), BEREICH POINTER, LAENGE BIN FIXED(15); XKQ6100.EINGABE.FUNKTION = FKT; IF PGMSPA.AKT_VERTRAG > 0 THEN DO; XKQ6100.EINGABE.VTRNR = PGMSPA.AKT_VERTRAG; XKQ6100.EINGABE.HISTNR = PGMSPA.HISTNR_NEU; END; ELSE DO; XKQ6100.EINGABE.VTRNR = 0; XKQ6100.EINGABE.HISTNR = 0; END; XKQ6100.EINGABE.PERSNR = DC_INFO.PERSNR; XKQ6100.EINGABE.TRANSAKT = 'KS74'; XKQ6100.EINGABE.VORG_SCHL = ' '; XKQ6100.EINGABE.ZEILEN_ART = ' '; XKQ6100.ERST_UNG = 0; XKQ6100.LETZT_UNG = 0; XKQ6100.AB_LFDNR = AB_LFDNR; XKQ6100.BEREICH = BEREICH; XKQ6100.LAENGE = LAENGE; XKQ6100.P_SQLCA = ADDR(SQLCA); $UCALL('MKQ6100'); SELECT(XKQ6100.RETCODE); WHEN(0); OTHERWISE $UPRO_ABBRUCH(XKQ6100.FMODUL, XKQ6100.FMODUL_RETCODE, XKQ6100.FMODUL_SQLCALLNR, ''); END; END PGM_SCHWEBE; 1/********************************************************************/ /* */ /* G E T _ M A I N */ /* */ /*------------------------------------------------------------------*/ /* - Dyn. Speicher allokieren: */ /* * Interne Tabelle ZEILEN_TAB */ /* */ /********************************************************************/ GET_MAIN: PROC REORDER; DCL L_ZEILEN_TAB BIN FIXED(31), RESPCODE BIN FIXED(15); DCL L_HINWEIS_TAB BIN FIXED(31), RESPCODE_H BIN FIXED(15); DCL L_AUSKUNFT_TAB BIN FIXED(31), RESPCODE_B BIN FIXED(15); DCL L_AKTLISTE_TAB BIN FIXED(31), RESPCODE_A BIN FIXED(15); DCL L_VARIABLE_TAB BIN FIXED(31), RESPCODE_V BIN FIXED(15); $KO_ALLOC(ZEILEN_TAB); IF ( EIBRESP ^= DFHRESP(NORMAL) ) THEN DO; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Dyn. Speicher ' !! 'konnte nicht allokiert werden: ZT !'; CALL ABBRUCH; END; $KO_ALLOC(HINWEIS_TAB); IF ( EIBRESP ^= DFHRESP(NORMAL) ) THEN DO; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Dyn. Speicher ' !! 'konnte nicht allokiert werden: HT !'; CALL ABBRUCH; END; $KO_ALLOC(AUSKUNFT_TAB); IF ( EIBRESP ^= DFHRESP(NORMAL) ) THEN DO; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Dyn. Speicher ' !! 'konnte nicht allokiert werden: AT !'; CALL ABBRUCH; END; $KO_ALLOC(AKTLISTE_TAB); IF ( EIBRESP ^= DFHRESP(NORMAL) ) THEN DO; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Dyn. Speicher ' !! 'konnte nicht allokiert werden: AL !'; CALL ABBRUCH; END; /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ $KO_ALLOC(VARIABLE_TAB); IF ( EIBRESP ^= DFHRESP(NORMAL) ) THEN DO; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Dyn. Speicher ' !! 'konnte nicht allokiert werden: VT !'; CALL ABBRUCH; END; /*---neuHSC:Policenauskunft - Ende ---------------------------------*/ END GET_MAIN; 1/********************************************************************/ /* */ /* F R E E _ M A I N */ /* */ /*------------------------------------------------------------------*/ /* - Dyn. belegten Speicher freigeben: */ /* * Struktur XKS6114 */ /* * Interne Tabelle ZEILEN_TAB */ /* */ /********************************************************************/ FREE_MAIN: PROC REORDER; EXEC CICS FREEMAIN DATA(ZEILEN_TAB) NOHANDLE ; IF ( EIBRESP ^= DFHRESP(NORMAL) ) THEN DO; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Dyn. Speicher ' !! 'konnte nicht deallokiert werden: ZT !'; CALL ABBRUCH; END; EXEC CICS FREEMAIN DATA(HINWEIS_TAB) NOHANDLE ; IF ( EIBRESP ^= DFHRESP(NORMAL) ) THEN DO; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Dyn. Speicher ' !! 'konnte nicht deallokiert werden: HT !'; CALL ABBRUCH; END; EXEC CICS FREEMAIN DATA(AUSKUNFT_TAB) NOHANDLE ; IF ( EIBRESP ^= DFHRESP(NORMAL) ) THEN DO; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Dyn. Speicher ' !! 'konnte nicht deallokiert werden: AT !'; CALL ABBRUCH; END; EXEC CICS FREEMAIN DATA(AKTLISTE_TAB) NOHANDLE ; IF ( EIBRESP ^= DFHRESP(NORMAL) ) THEN DO; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Dyn. Speicher ' !! 'konnte nicht deallokiert werden: AT !'; CALL ABBRUCH; END; /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ EXEC CICS FREEMAIN DATA(VARIABLE_TAB) NOHANDLE ; IF ( EIBRESP ^= DFHRESP(NORMAL) ) THEN DO; XKO0997.ANW_FEHLER(1) = 'SCHWERER FEHLER: Dyn. Speicher ' !! 'konnte nicht deallokiert werden: VT !'; CALL ABBRUCH; END; /*---neuHSC:Policenauskunft - Ende ---------------------------------*/ END FREE_MAIN; 1/********************************************************************/ /* */ /* L E S E _ M E L D U N G */ /* */ /*------------------------------------------------------------------*/ /* Ermitteln Meldung aus TBKO_MELDUNGEN und gibt eine entspr. auf- */ /* bereitete Meldung zurück */ /* */ /********************************************************************/ LESE_MELDUNG: PROC ( MELD_ID ) RETURNS ( CHAR(79) ) REORDER; DCL MELD_ID CHAR(*); XKO5038.EINGABE.MELDUNGEN_ID = MELD_ID ; XKO5038.MANDANT = U_SPA.MANDANT ; XKO5038.SPRACHCODE = U_SPA.SPRACHCODE; $UCALL('MKO5038'); SELECT ( XKO5038.RETCODE ); /* Gefunden */ WHEN (0) RETURN( MELD_ID !! ' ' !! XKO5038.AUSGABE.MELDUNGEN_TEXT ); /* Nicht gefunden */ WHEN (100) RETURN( 'Für MeldungsID ==>' !! MELD_ID !! '<== existiert kein Eintrag in TBKO_MELDUNGEN' ); /* Alles andere => Abbruch */ OTHERWISE $UPRO_ABBRUCH(XKO5038.FMODUL, XKO5038.FMODUL_RETCODE, XKO5038.FMODUL_SQLCALLNR, 'MKO5038 / RC = ' !! XKO5038.RETCODE); END; END LESE_MELDUNG; 1/********************************************************************/ /* */ /* L E S E _ P G M T E X T */ /* */ /*------------------------------------------------------------------*/ /* Liest Programmtext aus TBKO_KON_PGM_TXT und gibt den Text zurück */ /* via MKO5096. */ /* EINGABE: TEXTNR = Textnr aus Tabelle */ /* RETURN: = Gelesener Text */ /* */ /********************************************************************/ LESE_PGMTEXT: PROC ( TEXTNR ) RETURNS ( CHAR(132) VAR ) REORDER; DCL TEXTNR BIN fixed(15); XKO5096.EINGABE.PGM_NAME = 'MKS0074'; XKO5096.EINGABE.TEXTNR = TEXTNR; XKO5096.MANDANT = U_SPA.MANDANT ; XKO5096.SPRACHCODE = U_SPA.SPRACHCODE; $UCALL('MKO5096'); SELECT(XKO5096.RETCODE); WHEN(0); WHEN(100) XKO5096.AUSGABE.TEXT = '* NOT FOUND *'; OTHERWISE $UPRO_ABBRUCH(XKO5096.FMODUL, XKO5096.FMODUL_RETCODE, XKO5096.FMODUL_SQLCALLNR, 'MKO5096 / RC = ' !! XKO5096.RETCODE); END; /* select retcode */ RETURN(XKO5096.AUSGABE.TEXT); END LESE_PGMTEXT; 1/********************************************************************/ /* */ /* E R M _ V T R K A T */ /* */ /*------------------------------------------------------------------*/ /* Liest aus der tbko_vertragskat die bezeichnung zum schlüssel */ /* vtrkatkz */ /* EINGABE: vtrkatkz = schluessel */ /* RETURN: = Gelesener Text */ /* */ /********************************************************************/ ERM_VTRKAT: PROC (VTRKATKZ) REORDER RETURNS (CHAR(30)) REORDER; /* ---INPUT-Parameter-------------*/ DCL VTRKATKZ DEC FIXED(3,0); /* ---RETURN----------------------*/ DCL VTRKAT CHAR(30); DCLTBKO_VERTRAGSKAT.VTRKATKZ = VTRKATKZ; CALL DB2(06); IF SQLCA.SQLCODE = 0 THEN VTRKAT = DCLTBKO_VERTRAGSKAT.VTRKAT; ELSE VTRKAT = ''; RETURN(VTRKAT); END ERM_VTRKAT; 1/********************************************************************/ /* */ /* T S _ F E H L E R */ /* */ /*------------------------------------------------------------------*/ /* Anzeige Meldung bei Fehlern mit Meldungen von TS_*-Routinen */ /* */ /********************************************************************/ TS_FEHLER: PROC ( MELD_ID ) REORDER; DCL MELD_ID CHAR(*); CALL FEHLER(KS074DA.TRAN0,MELD_ID); END; 1/********************************************************************/ /* */ /* S P _ U E B E R N E H M E N */ /* */ /*------------------------------------------------------------------*/ /* Standard ST_PROC-Fehlerhandling bei schwerwiegenden Fehlern */ /* => MKO0997 */ /* */ /********************************************************************/ SP_UEBERNEHMEN: PROC(RC,EC,MSG) REORDER; DCL RC BIN FIXED(31); DCL EC BIN FIXED(31); DCL MSG CHAR(500) VARYING; SP_RC = RC; SP_EC = EC; SP_MESSAGE = MSG; END SP_UEBERNEHMEN; 1/********************************************************************/ /* */ /* S P _ A B R U C H */ /* */ /*------------------------------------------------------------------*/ /* Standard ST_PROC-Fehlerhandling bei schwerwiegenden Fehlern */ /* => MKO0997 */ /* */ /********************************************************************/ SP_ABBRUCH: PROC ( SPNAME ) REORDER; DCL SPNAME CHAR(8); SPA.FEHL_INFO.UPGM = SPNAME; SPA.FEHL_INFO.RETCODE = SP_RC; SPA.FEHL_INFO.CALLNR = SP_EC; XKO0997.ANW_FEHLER(1) = SUBSTR(SP_MESSAGE,1,78); XKO0997.ANW_FEHLER(2) = SUBSTR(SP_MESSAGE,79,157); CALL ABBRUCH; END SP_ABBRUCH; 1/********************************************************************/ /* */ /* A B B R U C H */ /* */ /*------------------------------------------------------------------*/ /* Standard Kompass-Fehlerhandling bei schwerwiegenden Fehlern */ /* => MKO0997 */ /* */ /********************************************************************/ %INCLUDE SKOABBR8; 1/********************************************************************/ /* */ /* I N I T _ E R S T A U S W A H L */ /* */ /*------------------------------------------------------------------*/ /* zuruecksetzen der Vertragsabhaengigen Felder in der Maske */ /* */ /********************************************************************/ INIT_ERSTAUSWAHL: PROC REORDER; KS074DA.BEARBNR = ''; KS074DA.JNETTO = ''; KS074DA.HISTNRN = ''; KS074DA.AENDDTN = ''; KS074DA.BEARDTN = ''; KS074DA.BEARBST = ''; KS074DA.VTBGDTN = ''; KS074DA.PRODUKT = ''; PGMSPA.AKT_HISTNR = 0; PGMSPA.HISTNR_NEU = 0; PGMSPA.B_KOPF_KO = K_NEIN; PGMSPA.AKT_V_LFDNR = 0; MOD_SPA.BEARBNR = ''; MOD_SPA.JNETTO = ''; MOD_SPA.HISTNRN = ''; MOD_SPA.AENDDTN = ''; MOD_SPA.BEARDTN = ''; MOD_SPA.BEARBST = ''; MOD_SPA.VTBGDTN = ''; MOD_SPA.PRODUKT = ''; END INIT_ERSTAUSWAHL; 1/********************************************************************/ /* */ /* I N I T - Z U S A T Z -I N F O - F E L D E R */ /* */ /*------------------------------------------------------------------*/ /* Belegung von Konstanten Informationen */ /* */ /********************************************************************/ INIT_Zusatz_Info_Felder: PROC REORDER; TAB_Zusatz_Infos.Anzahl_Felder = 4; TAB_Zusatz_Infos.Eintrag(1).Lfdnr = 1; TAB_Zusatz_Infos.Eintrag(1).BS_Feld_Name = 'VBWEG'; TAB_Zusatz_Infos.Eintrag(1).Variablen_Name = 'Vertriebsweg'; TAB_Zusatz_Infos.Eintrag(2).Lfdnr = 2; TAB_Zusatz_Infos.Eintrag(2).BS_Feld_Name = 'TARIFG'; TAB_Zusatz_Infos.Eintrag(2).Variablen_Name = 'Tarifgeneration'; TAB_Zusatz_Infos.Eintrag(3).Lfdnr = 3; TAB_Zusatz_Infos.Eintrag(3).BS_Feld_Name = 'VARTEXT'; /* AEND003 */ TAB_Zusatz_Infos.Eintrag(3).Variablen_Name = 'Variablentext'; TAB_Zusatz_Infos.Eintrag(4).Lfdnr = 4; TAB_Zusatz_Infos.Eintrag(4).BS_Feld_Name = 'VARWERT'; /* AEND003 */ TAB_Zusatz_Infos.Eintrag(4).Variablen_Name = 'Variablenwert'; END INIT_Zusatz_Info_Felder; 1/********************************************************************/ /* */ /* E R S T M A S K E */ /* */ /*------------------------------------------------------------------*/ /* - Aufbau_Auskunft_VTRAUSWAHL */ /* - Aufbau Liste in PGM_Schwebe */ /* */ /********************************************************************/ ERSTMASKE: PROC (VSNR, START_LISTE) RETURNS( BIN FIXED(15) ) REORDER; /* IN_PARAMETER */ DCL VSNR char (10); DCL START_LISTE BIN FIXED(15); /* OUT_PARAMETER */ /*---RETURN ------------------*/ DCL ANZ_VTRNR BIN FIXED(15); /*---lokale variable----------*/ DCL ERST_LI_ZEILE BIN FIXED(15); DCL ERST_LI_NR BIN FIXED(15); DCL ANZ_LI BIN FIXED(15); /* Rumpf Beginn ERSTMASKE -----------------------------------------*/ ERST_LI_NR = 0; ERST_LI_ZEILE = 0; ANZ_LI = 0; ANZ_VTRNR = 0; /*---------------------------------------------------------------*/ /* Aufbau Auskunft f}r VTRAUS in GTT : PI_AUSKUNFT */ /*---------------------------------------------------------------*/ /*---- neuer aufruf MKS1314 */ PGMSPA.B_KOPF_KD = AUFRUF_VTRAUS(START_LISTE); /*---- Bereitstellen Kopfdaten: entweder aus den SP_Parametern */ /* oder selber aus KAVIS besorgen */ IF ( PGMSPA.B_KOPF_KD = K_JA ) THEN CALL AUFBEREITEN_KD_DATEN(SPA.PROJEKT.VSNR); ELSE CALL KD_DATEN_AUS_KAVIS(SPA.PROJEKT.VSNR); /*--------------------------------------------------------------*/ /*---- GTT --> AUSKUNFT : Funktion return(ANZ_Listen) */ /*--------------------------------------------------------------*/ /* Anzahl Listen kann nur 1 sein, weil erstmal nur die vertraege*/ /* gelesen wurden }ber mks1314; alles andere ist fehler */ /* die listennummer,unter der die vertraege abgespeichert wurden*/ /* wird zurueckgereicht und soll der li-start_nr entsprechen */ /* in der erst_li_zeile steht die Referenz_zeile aus der */ /* Tabelle Auskunft_Tab, ab hier ist die aktuelle, erste Liste */ /*--------------------------------------------------------------*/ ANZ_LI = AUFBAU_AUSKUNFT(ERST_LI_NR, ERST_LI_ZEILE); /*--------------------------------------------------------------*/ /*---- anzuzeigende information ermitteln */ /*--------------------------------------------------------------*/ SELECT (ANZ_LI); /* korrekterweise beim erstaufruf ist nur eine liste der zur vsnr gehoerenden Vertraege geliefert */ WHEN (1) DO; /* aktualisieren liste, startzeile, pf12_stack */ /* ausser der Reihe hier, sonst nur in Folgeliste */ PGMSPA.AKT_SEITE = 1; PGMSPA.NXT_LISTE = ERST_LI_NR; CALL AKTUAL_LISTE; PGMSPA.NXT_PI_ZEILE = ERST_LI_ZEILE; CALL AKTUAL_PI_ZEILE; PGMSPA.ANZ_PI_ZEILEN = AUSKUNFT_TAB.ANZAHL_ZEILEN; ANZ_VTRNR = AUSKUNFT_TAB.ANZAHL_ZEILEN; /* STACK fuer PF12 aufbauen : erster Eintrag */ PGMSPA.PF12_STACK.ZEIGER = ADD_PF12_STACK (PGMSPA.AKT_LISTE, PGMSPA.AKT_PI_ZEILE); IF ANZ_VTRNR >= 1 THEN DO; PGMSPA.NXT_VERTRAG = AUSKUNFT_TAB.VTRNR(ERST_LI_ZEILE); PGMSPA.AKT_V_LFDNR = 1; SPA.PROJEKT.VTRNR = PGMSPA.NXT_VERTRAG; end; END; /* when anz_li = 1 */ WHEN (0) do; /*---- ANZ_Zeilen = 0 : kein Vertrag */ $UPRO_ABBRUCH('MKS0074', 7401, ANZ_LI, 'kein vertrag gefunden'); end; OTHERWISE do; /*---- anderer Fehler */ $UPRO_ABBRUCH('MKS0074', 7402, ANZ_LI, 'bei aufbau Vertragsauswahl mehr als eine liste'); END; END; /* select anz_li */ RETURN(ANZ_VTRNR); END ERSTMASKE; 1/********************************************************************/ /* */ /* F O L G E M A S K E */ /* */ /*------------------------------------------------------------------*/ /* - Aufbau_Auskunft_VTROBJ und folgende listen */ /* - Aufbau Listen in PGM_Schwebe */ /* */ /********************************************************************/ FOLGEMASKE: PROC (START_LISTE, FOLG_LI_NR, FOLG_LI_ZEI) RETURNS( BIN FIXED(15) ) REORDER; /* IN_PARAMETER */ DCL START_LISTE BIN FIXED(15); /* OUT_PARAMETER */ DCL FOLG_LI_NR BIN FIXED(15); DCL FOLG_LI_ZEI BIN FIXED(15); /*---RETURN ------------------*/ DCL ANZ_LI BIN FIXED(15); /* lokale variable */ /* Rumpf Beginn Folgemaske--------------------------------------*/ ANZ_LI = -1; FOLG_LI_NR = 0; FOLG_LI_ZEI = 0; IF PGMSPA.AKT_VERTRAG = 0 THEN DO; /*-----------------------------------------------------*/ /* fuer die ermittlung der Zeilenanspruenge */ /* und die spaetere erstellung der Tabelle */ /* AKTLISTE_TAB aus der PI_AUSKUNFT/AUSKUNFT_TAB */ /*-----------------------------------------------------*/ /* aktuelle AUSKUNFT_TAB, die zur letzten Anzeige passt*/ ANZ_LI = HOLE_AKT_AUSKUNFT(); PGMSPA.B_KOPF_KO = K_NEIN; FOLG_LI_NR = PGMSPA.Akt_Liste; FOLG_LI_ZEI = PGMSPA.Akt_PI_Zeile; END; ELSE DO; /*-----------------------------------------------------*/ /* Daten holen ueber Stored Procedure */ /*-----------------------------------------------------*/ PGMSPA.B_KOPF_KO = AUFRUF_VTROBJ(START_LISTE); IF PGMSPA.B_KOPF_KO = K_JA THEN DO; PGMSPA.HISTNR_ALT = PGMSPA.HISTNR_NEU; PGMSPA.HISTNR_NEU = SP15_HISTNR; PGMSPA.AENDDT_ALT = PGMSPA.AENDDT_NEU; PGMSPA.AENDDT_NEU = SP15_AENDDT; PGMSPA.NXT_HISTNR = PGMSPA.HISTNR_NEU; PGMSPA.PF12_STACK.ZEIGER = RESET_PF12_STACK(); /*-----------------------------------------------------*/ /* Aufbauen interne AUSKUNFT_TAB und speichern */ /* in Schwebe */ /*-----------------------------------------------------*/ ANZ_LI = AUFBAU_AUSKUNFT(FOLG_LI_NR, FOLG_LI_ZEI); SELECT (ANZ_LI); /*---- ANZ_Zeilen = 0 : keine informationen zu vtrobj */ WHEN (0) DO; SPA.FEHL_INFO.RETCODE = 7403; XKO0997.ANW_FEHLER(1) = 'KEINE LISTEN AUFGEBAUT '; CALL ABBRUCH; END; /*---- ANZ_Zeilen > 0 : aktuelle startliste setzen */ OTHERWISE DO; PGMSPA.HISTBL_LISTE = FOLG_LI_NR; END; END; END; ELSE DO; /* an dieser stelle koennen immer die kopfdaten ermittelt werden, weil vtrnr und histnr bekannt: sonst pgm_fehler */ SPA.FEHL_INFO.RETCODE = 7404; XKO0997.ANW_FEHLER(1) = 'unmoeglicher programmfehler '; CALL ABBRUCH; END; END; RETURN(ANZ_LI); END FOLGEMASKE; 1/********************************************************************/ /* */ /* E R M I T T L E - F O L G E L I S T E */ /* */ /*------------------------------------------------------------------*/ /* ermittelt parameter f}r die verwendung in aufbau_mod */ /* return, ob ermittlung m¦glich war */ /* und die parameter */ /* */ /********************************************************************/ ERMI_FOL: PROC(VTRNR,HISTNR,FOLG_LI_NR) RETURNS (BIN FIXED(15)) REORDER; /* IN_PARAMETER */ /* OUT_PARAMETER */ DCL HISTNR DEC FIXED(05,0); DCL VTRNR DEC FIXED(15,0); DCL FOLG_LI_NR BIN FIXED(15); /* RETURN_PARAMETER */ DCL RET_ZEI_NR BIN FIXED(15); /*--lokale variable-----------*/ DCL RESULT BIT(1); DCL I BIN FIXED(15); DCL REF_IND BIN FIXED(15); DCL ANZ_LI BIN FIXED(15); DCL B_EIN CHAR(1); DCL H_VTRNR DEC FIXED(15,0); DCL H_CODE CHAR(1) INIT(' '); /* RUMPF_BEGINN ermittle_Folgeliste */ FOLG_LI_NR = PGMSPA.AKT_LISTE; HISTNR = PGMSPA.AKT_HISTNR; VTRNR = PGMSPA.AKT_VERTRAG; H_VTRNR = 0; REF_IND = 0; RESULT = K_FALSE; RET_ZEI_NR = -1; /*--------------------------------------------------------------*/ /* ermittel der listennummer und ob neu die listen gelesen werd.*/ /*--------------------------------------------------------------*/ IF PGMSPA.B_EINGABE = K_JA THEN DO; SELECT (PGMSPA.AKT_LISTE); WHEN (K_LI_VTRAUS) DO; RET_ZEI_NR = ALGORITHMUS(H_VTRNR,FOLG_LI_NR); IF RET_ZEI_NR > 0 THEN DO; IF H_VTRNR > 0 THEN DO; VTRNR = H_VTRNR; HISTNR = 0; END; ELSE DO; FOLG_LI_NR = K_LI_VTRAUS; RET_ZEI_NR = PGMSPA.AKT_PI_ZEILE; END; END; ELSE DO; FOLG_LI_NR = K_LI_VTRAUS; END; END; WHEN (K_LI_VTROBJ) DO; RET_ZEI_NR = ALGORITHMUS(VTRNR,FOLG_LI_NR); END; OTHERWISE DO; RET_ZEI_NR = ALGORITHMUS(VTRNR,FOLG_LI_NR); END; END; END; ELSE DO; SELECT (DC_MID_8.TASTE); WHEN (K_DATFREI) DO; FOLG_LI_NR = PGMSPA.AKT_LISTE; RET_ZEI_NR = PGMSPA.AKT_PI_ZEILE; VTRNR = PGMSPA.AKT_VERTRAG; HISTNR = PGMSPA.AKT_HISTNR; END; WHEN (K_PF_04) DO; FOLG_LI_NR = K_LI_VTROBJ; RET_ZEI_NR = 1; VTRNR = PGMSPA.AKT_VERTRAG; HISTNR = PGMSPA.HISTNR_NEU; END; WHEN (K_PF_06) DO; FOLG_LI_NR = K_LI_VTROBJ; RET_ZEI_NR = 1; VTRNR = PGMSPA.AKT_VERTRAG; HISTNR = PGMSPA.HISTNR_NEU; END; WHEN (K_PF_12) DO; I = SUB_PF12_STACK(); IF (I > 0) THEN DO; RET_ZEI_NR = GET_PF12_ZEILE(I); FOLG_LI_NR = GET_PF12_LISTE(I); PGMSPA.PF12_AKT_SEITE = GET_PF12_SEITE(I); END; ELSE RET_ZEI_NR = 0; IF FOLG_LI_NR = K_LI_VTRAUS THEN DO; IF PGMSPA.ANZ_VERTRAEGE = 1 THEN RET_ZEI_NR = 0; ELSE DO; VTRNR = 0; HISTNR = 0; PGMSPA.B_KOPF_KO = K_NEIN; END; END; END; OTHERWISE DO; END; END; END; RETURN(RET_ZEI_NR); END ERMI_FOL; 1/********************************************************************/ /* */ /* A L G O R I T H M U S */ /* */ /*------------------------------------------------------------------*/ /* SUCHEN DER NEUEN LISTE AUFGRUND DER EINGABE IN DEN REFERENZEN */ /* */ /********************************************************************/ ALGORITHMUS: PROC(VTRNR,LINR) RETURNS( BIN FIXED(15) ) REORDER; /* output ------------------*/ DCL VTRNR DEC FIXED(15,0); DCL LINR BIN FIXED(15); /* return ------------------*/ DCL ret_zei_nr BIN FIXED(15); /* lokal -------------------*/ DCL RESULT BIT(1); DCL I BIN FIXED(15); DCL I_Z BIN FIXED(15); DCL REF_IND BIN FIXED(15); DCL B_EIN CHAR(1); /* procedurerumpf -----------------------------------------------*/ LINR = PGMSPA.AKT_LISTE; VTRNR = PGMSPA.AKT_VERTRAG; RET_ZEI_NR = -1; DO I = 1 TO PGMSPA.ANZ_ZEILEN WHILE ( RESULT = K_FALSE ); /*IF (Zeilen_tab.Aktion(I) > ' ') */ IF (ZEILEN_TAB.AKTION(I) ^= ' ') THEN DO; IF ( IN_REF(ZEILEN_TAB.AKTION(I),I,REF_IND,B_EIN) ) THEN DO; RESULT = K_TRUE; IF ZEILEN_TAB.EINTRAG.VTRNR(I) > 0 THEN DO; RET_ZEI_NR = 1; LINR = K_LI_VTROBJ; VTRNR = ZEILEN_TAB.EINTRAG.VTRNR(I); PGMSPA.AKT_V_LFDNR = I; END; ELSE DO; RET_ZEI_NR = ZEILEN_TAB.REF_TAB.LIS_ZEINR(I,REF_IND); LINR = AUSKUNFT_TAB.LNR(RET_ZEI_NR); END; END; ELSE DO; /* darf nach eingabe_ok nicht sein */ END; END; ELSE DO; RESULT = K_FALSE; END; /* in Referenz ' ' gefunden; naechste nehmen */ /* keine aktion gefordert ==> nur bl{ttern */ END; /* do i */ RETURN(RET_ZEI_NR); END ALGORITHMUS; 1/********************************************************************/ /* */ /* N E U A U F B A U _ P I _ A U S K U F T */ /* */ /*------------------------------------------------------------------*/ /* SUCHEN DER NEUEN LISTE AUFGRUND DER EINGABE IN DEN REFERENZEN */ /* MKS1315 ueber Folgemaske */ /* */ /********************************************************************/ NEUAUFBAU_PI_AUSKUNFT: PROC REORDER; DCL ANZ_LI BIN FIXED(15); DCL FOLG_LI_NR BIN FIXED(15); DCL FOLG_LI_ZEILE BIN FIXED(15); ANZ_LI = 0; FOLG_LI_NR = 0; FOLG_LI_ZEILE = 0; CALL DB2(4); /* DELETE PI_AUSKUNFT */ PGMSPA.PF12_STACK.ZEIGER = RESET_PF12_STACK(); /*---------------------------------*/ /* sp : mks1315 und PI_Auskunft */ /*---------------------------------*/ ANZ_LI = FOLGEMASKE(K_LI_VTROBJ, FOLG_LI_NR, FOLG_LI_ZEILE); IF ANZ_LI > 0 THEN DO; PGMSPA.NEUHOLEN = K_JA; PGMSPA.ANZ_PI_ZEILEN = AUSKUNFT_TAB.ANZAHL_ZEILEN; PGMSPA.AKT_SEITE = 1; PGMSPA.NXT_LISTE = FOLG_LI_NR; CALL AKTUAL_LISTE; PGMSPA.NXT_PI_ZEILE = FOLG_LI_ZEILE; CALL AKTUAL_PI_ZEILE; END; ELSE DO; /* eventuell falsche auskunft geholt : */ CALL FEHLER(DUMMY0,'KS7411E'); END; END NEUAUFBAU_PI_AUSKUNFT; 1/********************************************************************/ /* */ /* N E U H O L E N _ L I S T E */ /* */ /*------------------------------------------------------------------*/ /* SUCHEN DER NEUEN LISTE AUFGRUND DER EINGABE IN DEN REFERENZEN */ /* */ /********************************************************************/ NEUHOLEN_LISTE: PROC REORDER; /* aktuelle Liste erstellen */ PGMSPA.ANZ_ZEILEN_AK = HOLE_AKT_LISTE(PGMSPA.AKT_PI_ZEILE); PGMSPA.AKT_ZEILE = 1; PGMSPA.AKT_SEITE = 1; PGMSPA.PF12_STACK.ZEIGER = ADD_PF12_STACK(PGMSPA.AKT_LISTE, PGMSPA.AKT_PI_ZEILE); END NEUHOLEN_LISTE; 1/********************************************************************/ /* */ /* A U F R U F _ V T R A U S */ /* */ /*------------------------------------------------------------------*/ /* - Aufbau_Auskunft_VTRAUSWAHL ueber mks1314 */ /* */ /********************************************************************/ AUFRUF_VTRAUS: PROC (start_liste) RETURNS (CHAR(1)) REORDER; /* INPUT */ DCL start_liste BIN FIXED(15); /* RETURN */ DCL KD CHAR(1); /*---- Parameter f}r SP - Aufruf MKS1314 setzen */ KD = K_NEIN; SP14_MANDANT = U_SPA.MANDANT; SP14_SPRACHCODE = U_SPA.SPRACHCODE; SP14_VSNR = SPA.VSNR; SP14_START_LISTE = START_LISTE; SP14_BEARBNR = ''; SP14_TITEL = ''; SP14_NAME = ''; SP14_VNAME = ''; SP14_ADRSTR = ''; SP14_ADRORT = ''; SP14_GEBDAT = ''; SP14_TELEFON = ''; SP14_KUNDENKZ = ''; SP14_QKDNR = ''; SP14_RC = 0; SP14_EC = 0; SP14_ERRMSG = ''; /*---- Aufruf MKS1314 : ermitteln KD-Daten und VTR-Liste */ EXEC SQL CALL QV_MKS1314(:SP14_MANDANT, :SP14_SPRACHCODE , :SP14_VSNR, :SP14_start_liste , :SP14_BEARBNR, :SP14_TITEL, :SP14_NAME , :SP14_VNAME, :SP14_ADRSTR, :SP14_ADRORT , :SP14_GEBDAT, :SP14_TELEFON, :SP14_KUNDENKZ , :SP14_QKDNR , :SP14_EC, :SP14_ERRMSG, :SP14_RC ); /*---- Ausfuehrung und Returncode pruefen */ IF (SQLCA.SQLCODE ^= 0) THEN DO; $UPRO_ABBRUCH('MKS1314',1314,0,'AUFRUF STORED-PROCEDURE'); END; CALL SP_UEBERNEHMEN(SP14_RC, SP14_EC, SP14_ERRMSG); SELECT (SP14_RC); WHEN (K_SP_ABBRUCH) DO; CALL SP_ABBRUCH('MKS1314'); END; WHEN (K_SP_AUSSTEUERN) DO; B_FEHLER = K_TRUE; KS074DA.BENUMELD = SUBSTR(SP_MESSAGE,1,79); $UPRO_ABBRUCH('MKS1314',SP14_RC,SP14_EC, SUBSTR(SP_MESSAGE,1,79)); END; WHEN (K_SP_WARNUNG) DO; KS074DA.BENUMELD = SUBSTR(SP_MESSAGE,1,79); END; /*---- Positivfall: */ WHEN (K_SP_OK) DO; /*------- Code - Pr}fung (= 3636 ), solange mki3010 */ /* verwendet werden soll 3011 */ IF SP14_EC = 3636 /*------- Positivfall: B-Kopf-Kd = K(ompass = false */ THEN KD = K_NEIN; /*------- Normalfall : B-Kopf-Kd = I(npu = True */ ELSE KD = K_JA; END; OTHERWISE DO; $UPRO_ABBRUCH('MKS1314',1314,0, 'RC_CODE >= 17'); END; END; RETURN(KD); END AUFRUF_VTRAUS; 1/********************************************************************/ /* */ /* A U F R U F _ V T R O B J und ff */ /* */ /*------------------------------------------------------------------*/ /* - Aufruf_VTROBJ _VTRobjekte }ber mks1315 */ /* */ /********************************************************************/ AUFRUF_VTROBJ: PROC (start_liste) RETURNS (CHAR(1)) REORDER; /* INPUT */ DCL start_liste BIN FIXED(15); /* RETURN */ dcl B_KO char(1); /* lokale Variable */ DCL BEARBNR_PIC PIC'ZZZZ9'; /*---- Parameter f}r SP - Aufruf MKS1315 setzen */ B_KO = K_NEIN; SP15_MANDANT = U_SPA.MANDANT; SP15_SPRACHCODE = U_SPA.SPRACHCODE; SP15_VTRNR = PGMSPA.AKT_VERTRAG; SP15_START_LISTE = START_LISTE; SP15_HISTNR = PGMSPA.HISTNR_NEU; SP15_BEARBNR = 0; SP15_AENDDT = ''; SP15_VTRBEGDT = ''; SP15_PRODUKT = ''; SP15_BANKEZ = ''; SP15_JNETTO = ''; SP15_EC = 0; SP15_ERRMSG = ''; SP15_RC = 0; /*---- Aufruf MKS1315 : ermitteln Ko-Daten und */ /* VTROBJ_liste und ff */ EXEC SQL CALL QV_MKS1315(:SP15_MANDANT, :SP15_SPRACHCODE , :SP15_VTRNR, :SP15_START_LISTE, :SP15_HISTNR , :SP15_BEARBNR, :SP15_AENDDT, :SP15_VTRBEGDT , :SP15_PRODUKT, :SP15_BANKEZ, :SP15_JNETTO , :SP15_EC, :SP15_ERRMSG, :SP15_RC ); /*--------------------------------------------------------*/ /* Ausfuehrung und Returncode pruefen */ /*--------------------------------------------------------*/ IF (SQLCA.SQLCODE ^= 0) THEN DO; $UPRO_ABBRUCH('MKS1315',1315,0,'AUFRUF STORED-PROCEDURE'); END; CALL SP_UEBERNEHMEN(SP15_RC, SP15_EC, SP15_ERRMSG); SELECT (SP15_RC); WHEN (K_SP_ABBRUCH) DO; CALL SP_ABBRUCH('MKS1315'); END; WHEN (K_SP_AUSSTEUERN) DO; $UPRO_ABBRUCH('MKS1315',SP15_RC,SP15_EC, SUBSTR(SP_MESSAGE,1,79)); END; /*---- Fehlerfall : Abbruch */ WHEN (K_SP_WARNUNG) DO; KS074DA.BENUMELD = SUBSTR(SP_MESSAGE,1,79); END; /*---- Positivfall: */ WHEN (K_SP_OK) DO; /*---- immer bei Positv:rc */ /*---- GTT --> AUSKUNFT : Funktion return(ANZ_Zeilen) */ /* --> PGM_SCHW (P: start=LiNr 00) */ /* Merken Listennr als VTR_LI */ KS074DA.PRODUKT = STRING(SP15_PRODUKT); KS074DA.JNETTO = STRING(SP15_JNETTO); KS074DA.VTBGDTN = STRING(SP15_VTRBEGDT); BEARBNR_PIC = SP15_BEARBNR; KS074DA.BEARBNR = BEARBNR_PIC; IF SP15_HISTNR > 0 THEN B_KO = K_JA; ELSE B_KO = K_NEIN; END; OTHERWISE DO; $UPRO_ABBRUCH('MKS1315',SP15_RC,5, 'RC_CODE >= 17'); END; END; /* select sp15_rc */ RETURN(B_KO); END AUFRUF_VTROBJ; 1/********************************************************************/ /* */ /* H O L E _ A K T _ A U S K U N F T */ /* */ /********************************************************************/ /* holt die auskunft_tab von der schwebe */ /* return : referenz_zeilennumer */ /* */ /********************************************************************/ HOLE_AKT_AUSKUNFT: PROC RETURNS( BIN FIXED(15)) REORDER; DCL ANZ_ZEILEN BIN FIXED(15); CALL PGM_SCHWEBE(K_SCHW_LOAD,k_sn_AUSKUNFT, P_AUSKUNFT_TAB,CSTG(AUSKUNFT_TAB)); /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ CALL PGM_SCHWEBE(K_SCHW_LOAD,k_li_variable, P_VARIABLE_TAB,CSTG(VARIABLE_TAB)); /*---neuHSC:Policenauskunft - Ende -------------------------------*/ ANZ_ZEILEN = AUSKUNFT_TAB.ANZAHL_ZEILEN; RETURN(ANZ_ZEILEN); END HOLE_AKT_AUSKUNFT; 1/********************************************************************/ /* */ /* A u f b a u - A u s k u n f t */ /* */ /*------------------------------------------------------------------*/ /* liest die ggt PI_AUSKUNFT aus und speicher die Listen in der */ /* PGM_SCHWEBE ab */ /* */ /********************************************************************/ AUFBAU_AUSKUNFT: PROC (LI_NR, LI_ERST_ZEI) RETURNS(BIN FIXED(15)) REORDER; /* IN_PARAMETER */ /* OUT_PARAMETER */ DCL LI_NR BIN FIXED(15); DCL LI_ERST_ZEI BIN FIXED(15); /* RETURN_PARAMETER */ DCL ANZ_LI BIN FIXED(15); /* lokale variable */ DCL ANZ_ZEILEN BIN FIXED(15); DCL AB_LFDNR BIN FIXED(15); DCL I BIN FIXED(15); DCL II BIN FIXED(15); DCL I_SP BIN FIXED(15); DCL I_S_ANZ BIN FIXED(15); DCL K BIN FIXED(15); DCL KK BIN FIXED(15); DCL REF_LI BIN FIXED(15); DCL REF_LI_V BIN FIXED(15); DCL REF_O BIN FIXED(15); DCL 1 VARIABLE_TAB_S ,2 ANZAHL_Variable BIN FIXED(15) ,2 EINTRAG($MAX_Variable) ,4 LNR BIN FIXED(15) ,4 ZNR BIN FIXED(15) ,4 TEXT CHAR(76) ,4 VTRNR DEC FIXED(15,0) ,4 ONR BIN FIXED(15) ; /*--- interne proceduren ---*/ SICHERVARTAB: PROC (BEGINN) RETURNS(BIN FIXED(15)); DCL BEGINN BIN FIXED(15); DCL I_RET BIN FIXED(15); DCL I_S BIN FIXED(15); DCL I_V BIN FIXED(15); DCL L_S BIN FIXED(15); I_S = 0; I_V = BEGINN; L_S = VARIABLE_TAB(BEGINN).LNR; DO WHILE (I_S <= $MAX_VARIABLE & L_S = 1); $INCR(I_S); VARIABLE_TAB_S.EINTRAG(I_S) = VARIABLE_TAB.EINTRAG(I_V), BY NAME; $INCR(I_V); L_S = VARIABLE_TAB(I_V).LNR; END; I_RET = I_S; RETURN(I_RET); END SICHERVARTAB; RESTOREVARTAB: PROC (ZEILEN); DCL ZEILEN BIN FIXED(15); DCL I_S BIN FIXED(15); DO I_S = 1 TO ZEILEN BY 1; VARIABLE_TAB.EINTRAG(I_S) = VARIABLE_TAB_S.EINTRAG(I_S), BY NAME; END; VARIABLE_TAB.ANZAHL_VARIABLE = ZEILEN; END RESTOREVARTAB; /* RUMPF_BEGINN aufbau-auskunft ------------------------------------*/ VARIABLE_TAB_S = ''; I_S_ANZ = 0; II = 0; I_SP = 0; KK = 0; ANZ_LI_ZEI_V = 0; AUSKUNFT_TAB = ''; I = 0; K = 0; ANZ_LI_ZEI = 0; /* init Ausgabe-Parameter */ LI_NR = 0; LI_ERST_ZEI = 0; /* vorab zaehlen */ EXEC SQL SELECT COUNT(*) INTO :O_ZAEHLER FROM (SELECT DISTINCT(ONR) FROM GTKS_PI_AUSKUNFT A WHERE ONR ^= 0 ) AS TAB ; PGMSPA.ANZ_OBJEKTE = O_ZAEHLER; EXEC SQL SELECT COUNT (*) INTO :ANZ_LI_ZEI FROM (SELECT DISTINCT(LNR) FROM GTKS_PI_AUSKUNFT B WHERE LNR >= 10) AS TAB ; /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ /* ur WHERE LNR ^= 0 ) */ /* Lnr 1-9 fuer speziels */ /* neu WHERE LNR >= 10) */ EXEC SQL SELECT COUNT (*) INTO :ANZ_LI_ZEI_V FROM (SELECT DISTINCT(LNR) FROM GTKS_PI_AUSKUNFT C WHERE LNR BETWEEN 1 AND 9 ) AS TAB ; IF ANZ_LI_ZEI_V > 0 THEN DO; /* Initialisieren der Variable_Tab vor neuem reinkopieren aus GTKS */ IF VARIABLE_TAB(1).LNR = 1 THEN DO; I_S_ANZ = SICHERVARTAB(1); CALL INIT_VARIABLE_TAB; CALL RESTOREVARTAB(I_S_ANZ); END; ELSE DO; CALL INIT_VARIABLE_TAB; END; END; /*---neuHSC:Policenauskunft - Ende -------------------------------*/ /* eigentlicher Aufbau der Variablenliste und der Auskunftsliste */ PGMSPA.ANZ_LISTEN = ANZ_LI_ZEI; CALL DB2(1); /* Open Cursor */ CALL DB2(2); /* Fetch first */ REF_O = DCLGTKS_PI_AUSKUNFT.ONR; REF_LI = DCLGTKS_PI_AUSKUNFT.LNR; K = 1; KK = 1; /*---neuHSC:Policenauskunft - Beginn -------------------------------*/ IF REF_LI < 10 THEN DO; REF_LI_V = REF_LI; /*--------------------------------------------------------*/ /* Zeilen aus GTT lesen und in ZEILEN_TAB uebernehmen */ /*--------------------------------------------------------*/ DO WHILE ( SQLCA.SQLCODE = 0 & II <= $MAX_AUSKUNFT & DCLGTKS_PI_AUSKUNFT.LNR < 10 ); $INCR(II); /* AEND005A: ABBRUCH FALLS UEBERLAUF */ IF II > $MAX_AUSKUNFT THEN DO; XKO0997.ANW_FEHLER(1) = 'Schwerer Fehler: Max.Anzahl von' !! ' Zeilen in AUSKUNFT_TAB ueber' !! 'schritten.'; XKO0997.ANW_FEHLER(2) = 'Bitte AE2 informierenÜ' !! ' (REF_LI= ' !! REF_LI !! ')'; CALL ABBRUCH; END; /* AEND005E */ /* Ausschluss Auswahlzeile */ STRING(VARIABLE_ZEILE) = DCLGTKS_PI_AUSKUNFT.ZTEXT; IF VARIABLE_ZEILE.T1 = ' ' & VERIFY(VARIABLE_ZEILE.VAR_NUMMER,'0123456789') = 0 THEN DO; $INCR(I_SP); /*--------------------------------------------------------*/ /* Merkmalname / aktionionscode */ /*--------------------------------------------------------*/ VARIABLE_TAB(I_SP).LNR = DCLGTKS_PI_AUSKUNFT.LNR; VARIABLE_TAB(I_SP).ZNR = DCLGTKS_PI_AUSKUNFT.ZNR; VARIABLE_TAB(I_SP).TEXT = DCLGTKS_PI_AUSKUNFT.ZTEXT; VARIABLE_TAB(I_SP).VTRNR = DCLGTKS_PI_AUSKUNFT.VTRNR; VARIABLE_TAB(I_SP).ONR = DCLGTKS_PI_AUSKUNFT.ONR; END; IF REF_LI_V ^= DCLGTKS_PI_AUSKUNFT.LNR THEN DO; $INCR(KK); REF_LI_V = DCLGTKS_PI_AUSKUNFT.LNR; END; CALL DB2(2); /* Fetch next */ END; /* schleife II */ VARIABLE_TAB.ANZAHL_VARIABLE = I_SP; REF_LI = DCLGTKS_PI_AUSKUNFT.LNR; I = II; CALL PGM_SCHWEBE(K_SCHW_SAVE,K_LI_VARIABLE, P_VARIABLE_TAB,CSTG(VARIABLE_TAB)); END; /* Variablenliste */ ELSE DO; /* TESTEINTRAEGE */ L_VAR_SATZ = ''; VARIABLE_ZEILE = ''; VARIABLE_ZEILE.VAR_NUMMER = '0001'; VARIABLE_ZEILE.VAR_NAME = 'VBWEG '; VARIABLE_ZEILE.VAR_WERT = 'T '; L_VAR_SATZ.TEXT = STRING(VARIABLE_ZEILE); L_VAR_SATZ.LNR = 2; L_VAR_SATZ.ZNR = 1; L_VAR_SATZ.VTRNR = DCLGTKS_PI_AUSKUNFT.VTRNR; L_VAR_SATZ.ONR = 0; VARIABLE_TAB.EINTRAG(1) = L_VAR_SATZ, BY NAME; VARIABLE_ZEILE = ''; VARIABLE_ZEILE.VAR_NUMMER = '0002'; VARIABLE_ZEILE.VAR_NAME = 'TARIFG '; VARIABLE_ZEILE.VAR_WERT = '12.12.1212 '; L_VAR_SATZ.TEXT = STRING(VARIABLE_ZEILE); L_VAR_SATZ.LNR = 3; L_VAR_SATZ.ZNR = 1; L_VAR_SATZ.VTRNR = DCLGTKS_PI_AUSKUNFT.VTRNR; L_VAR_SATZ.ONR = 1; VARIABLE_TAB.EINTRAG(2) = L_VAR_SATZ, BY NAME; /* AEND003 Anfang VARIABLE_ZEILE = ''; VARIABLE_ZEILE.VAR_NUMMER = '0003'; VARIABLE_ZEILE.VAR_NAME = 'VARTEXT '; VARIABLE_ZEILE.VAR_WERT = 'Koop-Partner '; L_VAR_SATZ.TEXT = STRING(VARIABLE_ZEILE); L_VAR_SATZ.LNR = 4; L_VAR_SATZ.ZNR = 1; L_VAR_SATZ.VTRNR = DCLGTKS_PI_AUSKUNFT.VTRNR; L_VAR_SATZ.ONR = 1; VARIABLE_TAB.EINTRAG(3) = L_VAR_SATZ, BY NAME; VARIABLE_ZEILE = ''; VARIABLE_ZEILE.VAR_NUMMER = '0004'; VARIABLE_ZEILE.VAR_NAME = 'VARWERT '; VARIABLE_ZEILE.VAR_WERT = 'Karstadt '; L_VAR_SATZ.TEXT = STRING(VARIABLE_ZEILE); L_VAR_SATZ.LNR = 5; L_VAR_SATZ.ZNR = 1; L_VAR_SATZ.VTRNR = DCLGTKS_PI_AUSKUNFT.VTRNR; L_VAR_SATZ.ONR = 1; VARIABLE_TAB.EINTRAG(3) = L_VAR_SATZ, BY NAME; VARIABLE_TAB.ANZAHL_VARIABLE = 4; AEND003 Ende */ L_VAR_SATZ = ''; VARIABLE_ZEILE = ''; END; IF REF_LI >= 10 THEN DO; /*---neuHSC:Policenauskunft - Ende -------------------------------*/ /*--------------------------------------------------------*/ /* Zeilen aus GTT lesen und in ZEILEN_TAB uebernehmen */ /*--------------------------------------------------------*/ LI_NR = DCLGTKS_PI_AUSKUNFT.LNR; LI_ERST_ZEI = I+1; DO WHILE ( SQLCA.SQLCODE = 0 & I <= $MAX_AUSKUNFT ); $INCR(I); /* AEND005A: ABBRUCH FALLS UEBERLAUF */ IF I > $MAX_AUSKUNFT THEN DO; XKO0997.ANW_FEHLER(1) = 'Schwerer Fehler: Max.Anzahl von' !! ' Zeilen in AUSKUNFT_TAB ueber' !! 'schritten.'; XKO0997.ANW_FEHLER(2) = 'Bitte AE2 informierenÜ' !! ' (REF_LI= ' !! REF_LI !! ')'; CALL ABBRUCH; END; /* AEND005E */ /*--------------------------------------------------------*/ /* Merkmalname / aktionionscode */ /*--------------------------------------------------------*/ AUSKUNFT_TAB(I).LNR = DCLGTKS_PI_AUSKUNFT.LNR; AUSKUNFT_TAB(I).ZNR = DCLGTKS_PI_AUSKUNFT.ZNR; AUSKUNFT_TAB(I).TEXT = DCLGTKS_PI_AUSKUNFT.ZTEXT; AUSKUNFT_TAB(I).VTRNR = DCLGTKS_PI_AUSKUNFT.VTRNR; AUSKUNFT_TAB(I).ONR = DCLGTKS_PI_AUSKUNFT.ONR; AUSKUNFT_TAB(I).AKT_CODE(1) = DCLGTKS_PI_AUSKUNFT.AKT1; AUSKUNFT_TAB(I).lis_zeinr(1) = DCLGTKS_PI_AUSKUNFT.LNR1; AUSKUNFT_TAB(I).AKT_CODE(2) = DCLGTKS_PI_AUSKUNFT.AKT2; AUSKUNFT_TAB(I).lis_zeinr(2) = DCLGTKS_PI_AUSKUNFT.LNR2; AUSKUNFT_TAB(I).AKT_CODE(3) = DCLGTKS_PI_AUSKUNFT.AKT3; AUSKUNFT_TAB(I).lis_zeinr(3) = DCLGTKS_PI_AUSKUNFT.LNR3; AUSKUNFT_TAB(I).AKT_CODE(4) = DCLGTKS_PI_AUSKUNFT.AKT4; AUSKUNFT_TAB(I).lis_zeinr(4) = DCLGTKS_PI_AUSKUNFT.LNR4; AUSKUNFT_TAB(I).AKT_CODE(5) = DCLGTKS_PI_AUSKUNFT.AKT5; AUSKUNFT_TAB(I).lis_zeinr(5) = DCLGTKS_PI_AUSKUNFT.LNR5; IF REF_LI ^= DCLGTKS_PI_AUSKUNFT.LNR THEN DO; $INCR(K); REF_LI = DCLGTKS_PI_AUSKUNFT.LNR; END; CALL DB2(2); /* Fetch next */ END; /* schleife i */ AUSKUNFT_TAB.ANZAHL_ZEILEN = I; IF AUSKUNFT_TAB.ANZAHL_ZEILEN = 1 & LI_NR = K_LI_VTRAUS THEN DO; AUSKUNFT_TAB.AKT_CODE(LI_ERST_ZEI,1) = 'X'; AUSKUNFT_TAB.lis_zeinr(LI_ERST_ZEI,1) = K_LI_VTROBJ; PGMSPA.B_EINGABE = K_JA; PGMSPA.AKT_AKTION = AUSKUNFT_TAB.AKT_CODE(LI_ERST_ZEI,1); END; /* sichern Auskunft_tab in Schwebe : inhalt vtraus */ CALL PGM_SCHWEBE(K_SCHW_SAVE,k_sn_AUSKUNFT, P_AUSKUNFT_TAB,CSTG(AUSKUNFT_TAB)); END; /* Auskunftslisten */ ANZ_LI = K; CALL DB2(3); /* close Cursor */ RETURN(ANZ_LI); END AUFBAU_AUSKUNFT; 1/********************************************************************/ /* */ /* H O L E _ A K T _ L I S T E */ /* */ /*------------------------------------------------------------------*/ /* liest die ggt PI_AUSKUNFT aus und speicher die Listen in der */ /* PGM_SCHWEBE ab */ /* */ /********************************************************************/ HOLE_AKT_LISTE: PROC (ZEI_NR) RETURNS (BIN FIXED(15) ) REORDER; /* IN_PARAMETER */ DCL ZEI_NR BIN FIXED(15); /* OUT_PARAMETER */ /* RETURN_PARAMETER */ DCL ANZ_ZEI BIN FIXED(15); /* lokale variable */ DCL I BIN FIXED(15); DCL K BIN FIXED(15); DCL LINR BIN FIXED(15); /* RUMPF_BEGINN hole_akt_liste -------------------------------------*/ ANZ_ZEI = 0; IF ( ZEI_NR > 0 ) THEN DO; I = ZEI_NR; K = 0; LINR = AUSKUNFT_TAB.LNR(ZEI_NR); DO WHILE ( I <= PGMSPA.ANZ_PI_ZEILEN & LINR = AUSKUNFT_TAB.LNR( I )); $INCR(K); /*--------------------------------------------------------*/ /* Merkmalname / aktionionscode */ /*--------------------------------------------------------*/ /* AKTLISTE_TAB.EINTRAG(I) = AUSKUNFT_TAB.EINTRAG(I), BY NAME; */ AKTLISTE_TAB(K).LNR = AUSKUNFT_TAB(I).LNR; AKTLISTE_TAB(K).ZNR = AUSKUNFT_TAB(I).ZNR; AKTLISTE_TAB(K).TEXT = AUSKUNFT_TAB(I).TEXT; AKTLISTE_TAB(K).VTRNR = AUSKUNFT_TAB(I).VTRNR; AKTLISTE_TAB(K).ONR = AUSKUNFT_TAB(I).ONR; AKTLISTE_TAB(K).AKT_CODE(1) = AUSKUNFT_TAB(I).AKT_CODE(1); AKTLISTE_TAB(K).lis_zeinr(1) = AUSKUNFT_TAB(I).lis_zeinr(1); AKTLISTE_TAB(K).AKT_CODE(2) = AUSKUNFT_TAB(I).AKT_CODE(2); AKTLISTE_TAB(K).lis_zeinr(2) = AUSKUNFT_TAB(I).lis_zeinr(2); AKTLISTE_TAB(K).AKT_CODE(3) = AUSKUNFT_TAB(I).AKT_CODE(3); AKTLISTE_TAB(K).lis_zeinr(3) = AUSKUNFT_TAB(I).lis_zeinr(3); AKTLISTE_TAB(K).AKT_CODE(4) = AUSKUNFT_TAB(I).AKT_CODE(4); AKTLISTE_TAB(K).lis_zeinr(4) = AUSKUNFT_TAB(I).lis_zeinr(4); AKTLISTE_TAB(K).AKT_CODE(5) = AUSKUNFT_TAB(I).AKT_CODE(5); AKTLISTE_TAB(K).lis_zeinr(5) = AUSKUNFT_TAB(I).lis_zeinr(5); if aktliste_tab(k).vtrnr > 0 then do; aktliste_tab(k).akt_code(1) = 'X'; aktliste_tab(k).lis_zeinr (1) = k_li_vtrobj; end; $INCR(I); END; /* SCHLEIFE I */ AKTLISTE_TAB.ANZAHL_ZEILEN = K; ANZ_ZEI = K; END; /* Zei_nr > 0 */ RETURN(ANZ_ZEI); END HOLE_AKT_LISTE; 1/********************************************************************/ /* */ /* I N _ R E F */ /* */ /*------------------------------------------------------------------*/ /* Prueft, ob eingegebener Aktioncode aus der Aktionsspalte */ /* in der Referenz dieser Zeile in der Liste (AUSKUNFT) */ /* enthalten ist, dh. ob Sprung auf Folgeliste gesetzt */ /* und korrekt angew{hlt */ /* */ /********************************************************************/ IN_REF: PROC (CODE, IX, REF_IND, B_EINGABE) RETURNS (BIT(1)) REORDER; /* IN_PARAMETER */ DCL CODE CHAR(1); DCL IX BIN FIXED(15); /* OUT_PARAMETER */ DCL REF_IND BIN FIXED(15); DCL B_EINGABE CHAR(1); /* RETURN_PARAMETER */ DCL RESULT BIT(1); /*---lokale variable */ DCL J BIN FIXED(15); /* RUMPF_BEGINN IN_REF */ RESULT = K_FALSE; B_EINGABE = K_NEIN; REF_IND = 0; DO J = 1 TO $MAX_REF_F WHILE (RESULT = K_FALSE); IF ZEILEN_TAB.AKT_CODE(IX,J) = CODE THEN DO; REF_IND = J; RESULT = K_TRUE; B_EINGABE = K_JA; PGMSPA.AKT_AKTION = CODE; END; END; RETURN(RESULT); END IN_REF; 1/********************************************************************/ /* */ /* R E F _ L E E R */ /* */ /*------------------------------------------------------------------*/ /* Prueft, ob alle aktion-Felder in der Referenzliste leer (also */ /* nicht besetzt) sind. Folge: es darf keine m¦glichkeit */ /* eingabe eiens Aktionscodes auf der Maske angeboten werden*/ /* return = TRUE : keine Referenz vorhanden */ /* */ /********************************************************************/ REF_leer: PROC (IX) RETURNS (BIT(1)) REORDER; /* IN_PARAMETER */ DCL IX BIN FIXED(15); /* OUT_PARAMETER */ /* RETURN_PARAMETER */ DCL RESULT BIT(1); /*---lokale variable */ DCL J BIN FIXED(15); DCL H_BLANK CHAR(1); /* RUMPF_BEGINN REF_leer */ RESULT = K_TRUE; H_BLANK = ' '; DO J = 1 TO $MAX_REF_F WHILE (RESULT = K_TRUE); IF ZEILEN_TAB.AKT_CODE(IX,J) ^= H_BLANK THEN DO; RESULT = K_FALSE; END; END; RETURN(RESULT); END REF_LEER; 1/********************************************************************/ /* */ /* I N I T _ P G M S P A */ /* */ /*------------------------------------------------------------------*/ /* vorbelegung pgmspa einmalig beim ersten aufruf der ks74 */ /* */ /********************************************************************/ INIT_PGMSPA: PROC REORDER; PGMSPA = ''; PGMSPA.VSNR = SPA.PROJEKT.VSNR; PGMSPA.HISTNR_NEU = 0; PGMSPA.HISTNR_ALT = 0; PGMSPA.AENDDT_NEU = ''; PGMSPA.AENDDT_ALT = ''; PGMSPA.VORG_SCHL = SPA.PROJEKT.VORG_SCHL; PGMSPA.ANZ_ZEILEN = 0; PGMSPA.AKT_SEITE = 0; PGMSPA.AKT_ZEILE = 0; PGMSPA.ANZ_HINWEISE = 0; PGMSPA.AKT_HINWEIS = 0; PGMSPA.SPA_ZUSTAND = ' '; PGMSPA.AKT_Aktion = ' '; PGMSPA.ANZ_ZEILEN_AK = 0; PGMSPA.AKT_ZEILE_AK = 0; PGMSPA.ERST_ZEILE_AK = 0; PGMSPA.ANZ_PI_ZEILEN = 0; PGMSPA.AKT_PI_ZEILE = 0; PGMSPA.VOR_PI_ZEILE = 0; PGMSPA.NXT_PI_ZEILE = 0; PGMSPA.ANZ_LISTEN = 0; PGMSPA.AKT_LISTE = 0; PGMSPA.VOR_LISTE = 0; PGMSPA.NXT_LISTE = 0; PGMSPA.B_KOPF_KO = K_NEIN; PGMSPA.B_KOPF_KD = K_NEIN; PGMSPA.B_EINGABE = K_NEIN; PGMSPA.NEUAUFBAU = K_NEIN; PGMSPA.NEUHOLEN = K_NEIN; PGMSPA.ANZ_VERTRAEGE = 0; PGMSPA.AKT_VERTRAG = 0; PGMSPA.VOR_VERTRAG = 0; PGMSPA.NXT_VERTRAG = 0; PGMSPA.AKT_HISTNR = 0; PGMSPA.VOR_HISTNR = 0; PGMSPA.NXT_HISTNR = 0; PGMSPA.AKT_AENDDT = ''; PGMSPA.VOR_AENDDT = ''; PGMSPA.NXT_AENDDT = ''; PGMSPA.ANZ_OBJEKTE = 0; PGMSPA.AKT_OBJEKT = 0; PGMSPA.VOR_OBJEKT = 0; PGMSPA.NXT_OBJEKT = 0; PGMSPA.AKT_V_LFDNR = 0; PGMSPA.AKT_O_LFDNR = 0; PGMSPA.AKT_L_LFDNR = 0; PF12_STACK.ZEIGER = INIT_PF12_STACK(); END INIT_PGMSPA; 1/********************************************************************/ /* */ /* I N I T _ P G M S P A */ /* */ /*------------------------------------------------------------------*/ /* vorbelegung pgmspa einmalig beim ersten aufruf der ks74 */ /* */ /********************************************************************/ INIT_VARIABLE_TAB: PROC REORDER; DCL I BIN FIXED(15); DO I = 1 TO $MAX_Variable by 1; VARIABLE_TAB.EINTRAG(I) = L_VAR_SATZ; END; VARIABLE_TAB.ANZAHL_VARIABLE = 0; END INIT_VARIABLE_TAB; 1/********************************************************************/ /* */ /* V A R T A B _ H A S */ /* */ /*------------------------------------------------------------------*/ /* suchen index der zu name gehoert */ /* */ /********************************************************************/ VARTAB_has: PROC(Name) returns(Bin Fixed(15)) reorder; dcl name char(24); dcl i_RET BIN FIXED(15); select (Name); when ('VBWEG') I_RET = 1; when ('TARIFG') I_RET = 2; when ('VARTEXT') I_RET = 3; /* AEND003 */ when ('VARWERT') I_RET = 4; /* AEND003 */ other I_RET = 0; end; RETURN(I_RET); END VARTAB_has; /********************************************************************/ /* */ /* D B 2 */ /* */ /*------------------------------------------------------------------*/ /* Sammlung von DB2-Statements */ /* */ /********************************************************************/ DB2: PROC ( CALLNR ) REORDER; DCL CALLNR BIN FIXED(15); SPA.PROJEKT.CALLNR = CALLNR ; SPA.PROJEKT.UPGM = 'DB2'; SELECT ( CALLNR ); /*-----------------------------------------------------------*/ /* 01: Open Cursor C_GET_AUSKUNFT */ /*-----------------------------------------------------------*/ WHEN(1) DO; EXEC SQL OPEN C_GET_AUSKUNFT; ; SELECT(SQLCA.SQLCODE); WHEN(0); OTHERWISE DO; SPA.FEHL_INFO.RETCODE = 200; XKO0997.ANW_FEHLER(1) = 'DB2(1): Open Cursor C_GET_auskuf'; SPA.FEHL_INFO.CALLNR = 01; CALL ABBRUCH; END; END; END; /* when(1) */ /*-----------------------------------------------------------*/ /* 02: Fetch Cursor C_GET_DIALOG (anzuzeigende Zeilen) */ /*-----------------------------------------------------------*/ WHEN(2) DO; EXEC SQL FETCH C_GET_AUSKUNFT INTO :DCLGTKS_PI_AUSKUNFT.LNR ,:DCLGTKS_PI_auskunft.ZNR ,:DCLGTKS_PI_auskunft.Ztext:ind_ztext ,:DCLGTKS_PI_auskunft.Akt1:ind_akt1 ,:DCLGTKS_PI_auskunft.lnr1:ind_lnr1 ,:DCLGTKS_PI_auskunft.Akt2:ind_akt2 ,:DCLGTKS_PI_auskunft.lnr2:ind_lnr2 ,:DCLGTKS_PI_auskunft.Akt3:ind_akt3 ,:DCLGTKS_PI_auskunft.lnr3:ind_lnr3 ,:DCLGTKS_PI_auskunft.Akt4:ind_akt4 ,:DCLGTKS_PI_auskunft.lnr4:ind_lnr4 ,:DCLGTKS_PI_auskunft.Akt5:ind_akt5 ,:DCLGTKS_PI_auskunft.lnr5:ind_lnr5 ,:DCLGTKS_PI_auskunft.vtrnr:ind_vtrnr ,:DCLGTKS_PI_auskunft.onr:ind_onr ; SELECT (SQLCA.SQLCODE); WHEN(0); WHEN(100); OTHERWISE DO; SPA.FEHL_INFO.RETCODE = 200; XKO0997.ANW_FEHLER(1) = 'DB2(2): Fetch Cursor C_GET_auskun'; SPA.FEHL_INFO.CALLNR = 02; CALL ABBRUCH; END; END; IF ( IND_ztext = -1 ) THEN DCLGTKS_PI_auskunft.ztext = ' '; IF ( IND_vtrnr = -1 ) THEN DCLGTKS_PI_auskunft.vtrnr = 0; IF ( IND_ONR = -1 ) THEN DCLGTKS_PI_auskunft.ONR = 0; IF ( IND_akt1 = -1 ) THEN DCLGTKS_PI_auskunft.akt1 = ' '; IF ( IND_lnr1 = -1 ) THEN DCLGTKS_PI_auskunft.lnr1 = 0; IF ( IND_akt2 = -1 ) THEN DCLGTKS_PI_auskunft.akt2 = ' '; IF ( IND_lnr2 = -1 ) THEN DCLGTKS_PI_auskunft.lnr2 = 0; IF ( IND_akt3 = -1 ) THEN DCLGTKS_PI_auskunft.akt3 = ' '; IF ( IND_lnr3 = -1 ) THEN DCLGTKS_PI_auskunft.lnr3 = 0; IF ( IND_akt4 = -1 ) THEN DCLGTKS_PI_auskunft.akt4 = ' '; IF ( IND_lnr4 = -1 ) THEN DCLGTKS_PI_auskunft.lnr4 = 0; IF ( IND_akt5 = -1 ) THEN DCLGTKS_PI_auskunft.akt5 = ' '; IF ( IND_lnr5 = -1 ) THEN DCLGTKS_PI_auskunft.lnr5 = 0; END; /* when(2) */ /*-----------------------------------------------------------*/ /* 03: close Cursor C_GET_auskunft */ /*-----------------------------------------------------------*/ WHEN(3) DO; EXEC SQL CLOSE C_GET_AUSKUNFT ; SELECT(SQLCA.SQLCODE); WHEN(0); OTHERWISE DO; SPA.FEHL_INFO.RETCODE = 200; XKO0997.ANW_FEHLER(1) = 'DB2(3): Close Cursor C_GET_auskun'; SPA.FEHL_INFO.CALLNR = 03; CALL ABBRUCH; END; END; END; /* when(3) */ /*-----------------------------------------------------------*/ /* 04: delete PI_Auskunft : verwenden in derselben transakt. */ /*-----------------------------------------------------------*/ WHEN(4) DO; EXEC SQL DELETE FROM GTKS_PI_AUSKUNFT ; SELECT(SQLCA.SQLCODE); WHEN(0); OTHERWISE DO; SPA.FEHL_INFO.RETCODE = 200; XKO0997.ANW_FEHLER(1) = 'DB2(4): delete PI_AUSKUNFT '; SPA.FEHL_INFO.CALLNR = 04; CALL ABBRUCH; END; END; END; /* when(4) */ /******************************************************************/ /* 06 : TBKO_Vertragskat lesen */ /******************************************************************/ WHEN (06) DO; DCLTBKO_VERTRAGSKAT.MANDANT = U_SPA.MANDANT; DCLTBKO_VERTRAGSKAT.SPRACHCODE = U_SPA.SPRACHCODE; EXEC SQL SELECT VTRKAT INTO :DCLTBKO_VERTRAGSKAT.VTRKAT FROM TBKO_VERTRAGSKAT WHERE VTRKATKZ = :DCLTBKO_VERTRAGSKAT.VTRKATKZ AND MANDANT = :DCLTBKO_VERTRAGSKAT.MANDANT AND SPRACHCODE = :DCLTBKO_VERTRAGSKAT.SPRACHCODE ; SELECT (SQLCA.SQLCODE); WHEN (K_RC_OK); OTHERWISE DO; SPA.FEHL_INFO.RETCODE = 200; XKO0997.ANW_FEHLER (1)= 'FEHLER MKS0074 NACH SQL-CALL 06 - ' !! 'SQLCODE : ' !! sqlca.SQLCODE ; SPA.FEHL_INFO.CALLNR = 06; CALL ABBRUCH; END; END; END; /* WHEN (06) */ /*-------------------------------------------------------------*/ /* 40: select vtrkatkz der hoechsten historie */ /*-------------------------------------------------------------*/ WHEN(40) DO; EXEC SQL SELECT J1.VTRKATKZ INTO :DCLTBKO_VTRJOURNAL.VTRKATKZ FROM TBKO_VTRJOURNAL J1 WHERE VSNR = :DCLTBKO_VTRJOURNAL.VSNR AND VTRNR = : DCLTBKO_VTRJOURNAL.VTRNR AND VORG_LFDNR = 1 AND HISTNR = ( SELECT MAX(J2.HISTNR) FROM TBKO_VTRJOURNAL J2 WHERE J1.VTRNR = J2.VTRNR ) ; SELECT(SQLCA.SQLCODE); WHEN(0); OTHERWISE DO; SPA.FEHL_INFO.RETCODE = 200; XKO0997.ANW_FEHLER (1)= 'FEHLER MKS0074 NACH SQL-CALL 40 - ' !! 'SQLCODE : ' !! sqlca.SQLCODE ; SPA.FEHL_INFO.CALLNR = 40; CALL ABBRUCH(); END; END; END; /* when(40) */ /*-----------------------------------------------------------*/ /* 41: select vartkz der hoechsten historie */ /*-----------------------------------------------------------*/ WHEN(41) DO; EXEC SQL SELECT J1.VTRKATKZ INTO :DCLTBKO_VTRJOURNAL.VTRKATKZ FROM TBKO_VTRJOURNAL J1 WHERE VSNR = :DCLTBKO_VTRJOURNAL.VSNR AND VTRNR = : DCLTBKO_VTRJOURNAL.VTRNR AND VORG_LFDNR = 1 AND HISTNR = ( SELECT MAX(J2.HISTNR) FROM TBKO_VTRJOURNAL J2 WHERE J1.VTRNR = J2.VTRNR ) ; SELECT(SQLCA.SQLCODE); WHEN(0); OTHERWISE DO; SPA.FEHL_INFO.RETCODE = 200; XKO0997.ANW_FEHLER (1)= 'FEHLER MKS0074 NACH SQL-CALL 40 - ' !! 'SQLCODE : ' !! sqlca.SQLCODE ; SPA.FEHL_INFO.CALLNR = 40; CALL ABBRUCH(); END; END; END; /* when(41) */ /*-----------------------------------------------------------*/ /* Ungültige CallNr: */ /*-----------------------------------------------------------*/ OTHERWISE DO; SPA.FEHL_INFO.RETCODE = 201; XKO0997.ANW_FEHLER(1) = 'Ungültige CallNr bei Proc. DB2'; CALL ABBRUCH; END; /*-----------------------------------------------------------*/ END; /* select callnr */ END DB2; 1/********************************************************************/ /* */ /* A U F B E R E I T E N _ K D _ D A T E N */ /* */ /*------------------------------------------------------------------*/ /* f}llt in der maske die kundendaten_felder (name, adresse, ...) */ /* return, ob ermittlung und aufbereitung m¦glich war */ /* */ /********************************************************************/ AUFBEREITEN_KD_DATEN: PROC (VSNR) REORDER; /* IN_PARAMETER */ DCL VSNR CHAR(10); /* RETURN_PARAMETER */ /* RUMPF_BEGINN aufbereiten_kd_daten */ KS074DA.VSNR = VSNR; MOD_SPA.VSNR = VSNR; KS074DA.NAME = SUBSTR( SP14_NAME, 1, LEN(SP14_NAME)) !! ', ' !! SP14_VNAME; MOD_SPA.NAME = SUBSTR( SP14_NAME, 1, LEN(SP14_NAME)) !! ', ' !! SP14_VNAME; KS074DA.BEARBNR = SP14_BEARBNR; MOD_SPA.BEARBNR = SP14_BEARBNR; KS074DA.STRASSE = SP14_ADRSTR; MOD_SPA.STRASSE = SP14_ADRSTR; KS074DA.ORT = SP14_ADRORT; MOD_SPA.ORT = SP14_ADRORT; KS074DA.GEDAT = 'GEB.-DAT.: '!! SP14_GEBDAT; MOD_SPA.GEDAT = 'GEB.-DAT.: '!! SP14_GEBDAT; KS074DA.KOMMUN = 'TEL.: ' !! SP14_TELEFON; MOD_SPA.KOMMUN = 'TEL.: ' !! SP14_TELEFON; KS074DA.KDKZ = SP14_KUNDENKZ; MOD_SPA.KDKZ = SP14_KUNDENKZ; END AUFBEREITEN_KD_DATEN; 1/********************************************************************/ /* */ /* K D _ D A T E N _ A U S _ K A V I S */ /* */ /*------------------------------------------------------------------*/ /* füllt in der maske die kundendaten_felder (Name, Adresse, ...) */ /* */ /********************************************************************/ KD_DATEN_AUS_KAVIS: PROC(VSNR) REORDER; /* IN_PARAMETER */ DCL VSNR CHAR(10); /* RETURN_PARAMETER */ /* RUMPF_BEGINN kd_daten_aus_kavis */ IF VSNR = SPA.PROJEKT.VSNR THEN DO; KS074DA.VSNR = VSNR; MOD_SPA.VSNR = VSNR; CALL ERM_KAVIS_DATEN; END; /* --- nur für testzwecke ---- */ ELSE DO; KS074DA.VSNR = VSNR; KS074DA.NAME = 'testname'; KS074DA.BEARBNR = 99; KS074DA.STRASSE = 'teststrasse'; KS074DA.ORT = 'testort'; KS074DA.GEDAT = '11.11.1111'; KS074DA.KOMMUN = 'testfax'; KS074DA.KDKZ = 'HENRY MAX '; MOD_SPA.VSNR = VSNR; MOD_SPA.NAME = 'testname'; MOD_SPA.BEARBNR = 99; MOD_SPA.STRASSE = 'teststrasse'; MOD_SPA.ORT = 'testort'; MOD_SPA.GEDAT = '11.11.1111'; MOD_SPA.KOMMUN = 'testfax'; MOD_SPA.KDKZ = 'HENRY MAX '; end; END KD_DATEN_AUS_KAVIS; 1/********************************************************************/ /* */ /* E R M _ K A V I S _ D A T E N */ /* */ /********************************************************************/ /* KURZE FUNKTIONSBESCHREIBUNG */ /* - ERMITTELN VON NAME, TELEFON-NR, GEBDAT UND ADRESSE DES VN */ /* */ /********************************************************************/ ERM_KAVIS_DATEN: PROC; DCL KDNR_PIC PIC'99999999'; XKI3011E = ''; XKI3011A = ''; XKI3011E = ''; XKI3011E.MANDANT = U_SPA.MANDANT; XKI3011E.SPRACHCODE = U_SPA.SPRACHCODE; XKI3011E.VNR = SPA.PROJEKT.VSNR ; XKI3011E.BESTAKZ = '02'; /* VNR IST EINDEUTIG ! */ XKI3011E.VBEZAKZ(1) = 'N' ; /* VERSICHERUNGSNEHMER */ XKI3011E.VBEZAKZ(2) = 'B' ; /* BEITRAGSZAHLER */ XKI3011E.KUNDE = K_JA ; XKI3011E.ADRESSE = K_JA ; XKI3011E.BANK = K_JA ; XKI3011E.VERTRAG = K_JA ; XKI3011E.VERTRAGSBEZ = K_JA ; XKI3011E.ANZAHL_MAX = 2 ; /*------------------------*/ $UCALL ('MKI3011'); /* AUFRUF KAVIS-MODUL */ /*------------------------*/ SELECT (XKI3011M.RETCODE); WHEN (K_RC_OK, 32) DO; SPA.PROJEKT.ZWEIG = XKI3011A.ZWEIG(1); /*----------------------------------*/ /* Name */ /*----------------------------------*/ KS074DA.NAME = SUBSTR( XKI3011A.NAME(1), 1, LEN( XKI3011A.NAME(1) ) ) !! ', ' !! XKI3011A.VNAME(1); MOD_SPA.NAME = SUBSTR( XKI3011A.NAME(1), 1, LEN( XKI3011A.NAME(1) ) ) !! ', ' !! XKI3011A.VNAME(1); /*----------------------------------*/ /* Adresse */ /*----------------------------------*/ KS074DA.STRASSE = XKI3011A.STRASSE_POSTFACH(1); MOD_SPA.STRASSE = XKI3011A.STRASSE_POSTFACH(1); MOD_SPA.ORT = XKI3011A.PLZ(1) !! XKI3011A.ORT(1); KS074DA.ORT = XKI3011A.PLZ(1) !! XKI3011A.ORT(1); /*----------------------------------*/ /* Geburtsdatum */ /*----------------------------------*/ KS074DA.GEDAT = 'GEB.-DAT.: ' !! XKI3011A.GEBTT(1) !! '.' !! XKI3011A.GEBMM(1) !! '.' !! XKI3011A.GEBJJ(1); MOD_SPA.GEDAT = 'GEB.-DAT.: ' !! XKI3011A.GEBTT(1) !! '.' !! XKI3011A.GEBMM(1) !! '.' !! XKI3011A.GEBJJ(1); /*----------------------------------*/ /* Kommunikationseinrichtungen */ /*----------------------------------*/ KS074DA.KOMMUN = 'TEL.: ' !! SUBSTR( XKI3011A.PRIV_TELVORW(1), 1, LEN( XKI3011A.PRIV_TELVORW(1) )) !! '/' !! XKI3011A.PRIV_TELNR(1); MOD_SPA.KOMMUN = 'TEL.: ' !! SUBSTR( XKI3011A.PRIV_TELVORW(1), 1, LEN( XKI3011A.PRIV_TELVORW(1) )) !! '/' !! XKI3011A.PRIV_TELNR(1); /*----------------------------------*/ /* Bankeinzug */ /*----------------------------------*/ IF XKI3011A.KTONR(2) ^= '' & XKI3011A.BLZ(2) ^= '' THEN KS074DA.BANKEZ = 'J'; ELSE KS074DA.BANKEZ = 'N'; IF XKI3011A.KTONR(2) ^= '' & XKI3011A.BLZ(2) ^= '' THEN MOD_SPA.BANKEZ = 'J'; ELSE MOD_SPA.BANKEZ = 'N'; /*----------------------------------*/ /* Kundenkennzeichen */ /*----------------------------------*/ XKI3050E = '' ; XKI3050E.MANDANT = U_SPA.MANDANT; XKI3050E.SPRACHCODE = U_SPA.SPRACHCODE; XKI3050E.KDNR = XKI3011A(1).KDNR ; XKI3050E.SELECT_AUSGABE.KUKZ = 'J' ; XKI3050E.ANZAHL_MAX = 1 ; /*------------------------*/ $UCALL ('MKI3050'); /* KUNDENKENNZEICHEN Lesen*/ /*------------------------*/ /*------------------------*/ SELECT (XKI3050M.RETCODE); /* PRUEFUNG RETURNCODE */ /*------------------------*/ WHEN (0) DO; /*AEND001B*/ KS074DA.KDKZ = XKI3050A.TAB(1).KUKZ !! ' ' !! XKI3050A.TAB(1).KUKZBZ; MOD_SPA.KDKZ = XKI3050A.TAB(1).KUKZ !! ' ' !! XKI3050A.TAB(1).KUKZBZ; SPA.PROJEKT.KUKZ = XKI3050A.TAB(1).KUKZ ; END; /*------------------------*/ WHEN (63) DO; /* kein kukz gefunden */ SPA.PROJEKT.KUKZ = '' ; /*------------------------*/ KS074DA.KDKZ = '*'; MOD_SPA.KDKZ = '*'; END; WHEN (32) do; /* MEHR ALS 1 KUKZ VORH. */ /*AEND001B*/ KS074DA.KDKZ = XKI3050A.TAB(1).KUKZ !! ' ' !! SUBSTR( XKI3050A.TAB(1).KUKZBZ, 1 , LEN( XKI3050A.TAB(1).KUKZBZ ) ) !! MOD_SPA.KDKZ = XKI3050A.TAB(1).KUKZ !! ' ' !! SUBSTR( XKI3050A.TAB(1).KUKZBZ, 1 , LEN( XKI3050A.TAB(1).KUKZBZ ) ) !! ' ... und weitere ...'; MELDUNGEN_ID = 'KO0859E'; SPA.PROJEKT.KUKZ = XKI3050A.TAB(1).KUKZ ; END; /*AEND001E*/ OTHERWISE DO; /*------------------------*/ B_FEHLER = K_TRUE; /* FEHLERHAFTER KAVIS- */ /* AUFRUF */ /*------------------------*/ /*------------------------*/ IF XKI3050M.RETCODE >= 90 THEN /* PROGRAMMABBRUCH */ DO; /*------------------------*/ SPA.PROJEKT.FEHL_INFO.UPGM = 'MKI3050' ; SPA.PROJEKT.FEHL_INFO.RETCODE = XKI3050M.RETCODE ; XKO0997.ANW_FEHLER(1) = XKI3050M.MESSAGE ; CALL ABBRUCH; END; ELSE /*------------------------*/ /* ANZEIGE KAVIS- */ /* FEHLERMELDUNG */ /*------------------------*/ KS074DA.BENUMELD = 'KAVIS ' !! XKI3050M.MESSAGE ; END; END; END; OTHERWISE DO; SPA.PROJEKT.UPGM = 'MKI3011'; SPA.PROJEKT.RETCODE = XKI3011M.RETCODE; SPA.PROJEKT.CALLNR = ''; SQLCA = ''; SQLCA.SQLCODE = XKI3011M.DB2CODE; XKO0997.ANW_FEHLER(1) = XKI3011M.MESSAGE; CALL ABBRUCH; END; END; /* SELECT */ /*----------------------------------*/ /* (Quelle-)Kundennummer */ /*----------------------------------*/ KDNR_PIC = XKI3011A.KDNR(1); IF U_SPA.MANDANT = '1' /* AEND0018*/ THEN DO; /* KS074DA.QKDNR = XKI3011A.KDNR(1); */ KS074DA.QKDNR = KDNR_PIC; MOD_SPA.QKDNR = KDNR_PIC; /* MOD_SPA.QKDNR = XKI3011A.KDNR(1); */ END; /* END IF MANDANT=1 */ ELSE DO; /*AEND0018*/ KS074DA.QKDNR = KDNR_PIC; MOD_SPA.QKDNR = KDNR_PIC; /* KS074DA.QKDNR = ''; AEND0018 MOD_SPA.QKDNR = ''; AEND0018*/ END;/* END ERMITTELN QKDNR FUER NECKERMANN/KARSTADT AEND0018*/ END ERM_KAVIS_DATEN; 1/********************************************************************/ /* */ /* I N I T _ P F 1 2 _ S T A C K */ /* */ /********************************************************************/ /* alle eintraege loeschen */ /* return : Zeiger auf aktuelle position : 0 */ /* */ /********************************************************************/ INIT_PF12_STACK: PROC RETURNS( BIN FIXED(15)) REORDER; DCL IX_PF12 BIN FIXED(15); DCL IZ_PF12 BIN FIXED(15); DO IX_PF12 = 1 TO $MAX_PF12; PF12_STACK.REF_LINR(IX_PF12) = 0; PF12_STACK.REF_ZEINR(IX_PF12) = 0; PF12_STACK.REF_SEITNR(IX_PF12) = 0; END; IZ_PF12 = 0; RETURN(IZ_PF12); END INIT_PF12_STACK; 1/********************************************************************/ /* */ /* R E S E T _ P F 1 2 _ S T A C K */ /* */ /********************************************************************/ /* alle eintraege loeschen */ /* return : Zeiger auf aktuelle position : 0 */ /* */ /********************************************************************/ RESET_PF12_STACK: PROC RETURNS( BIN FIXED(15)) REORDER; DCL IX_PF12 BIN FIXED(15); DCL IZ_PF12 BIN FIXED(15); DO IX_PF12 = 2 TO $MAX_PF12; PF12_STACK.REF_LINR(IX_PF12) = 0; PF12_STACK.REF_ZEINR(IX_PF12) = 0; PF12_STACK.REF_SEITNR(IX_PF12) = 0; IZ_PF12 = 1; END; RETURN(IZ_PF12); END RESET_PF12_STACK; 1/********************************************************************/ /* */ /* U P D _ P F 1 2 _ S T A C K _ S E I T E */ /* */ /********************************************************************/ /* eine neue Referenz wird in den Stack eingetragen fuer die neue */ /* Liste referenziert auf die Zeilennummer in der PI-AUSKUNFT */ /* return : Zeiger auf aktuelle position im Stack */ /* */ /********************************************************************/ UPD_PF12_STACK_SEITE: PROC RETURNS( BIN FIXED(15)) REORDER; DCL IX_PF12 BIN FIXED(15); IX_PF12 = PGMSPA.PF12_STACK.ZEIGER; IF IX_PF12 > $MAX_PF12 THEN do; CALL FEHLER(DUMMY0,'KS7412E'); end; PF12_STACK.REF_SEITNR(IX_PF12) = PGMSPA.AKT_SEITE; PGMSPA.PF12_STACK.ZEIGER = IX_PF12; RETURN(IX_PF12); END UPD_PF12_STACK_SEITE; 1/********************************************************************/ /* */ /* A D D _ P F 1 2 _ S T A C K */ /* */ /********************************************************************/ /* eine neue Referenz wird in den Stack eingetragen fuer die neue */ /* Liste referenziert auf die Zeilennummer in der PI-AUSKUNFT */ /* return : Zeiger auf aktuelle position im Stack */ /* */ /********************************************************************/ ADD_PF12_STACK: PROC(LINR, ZEINR) RETURNS( BIN FIXED(15)) REORDER; /* IN-Parameter */ DCL LINR BIN FIXED(15); DCL ZEINR BIN FIXED(15); /* Return-Parameter */ DCL IX_PF12 BIN FIXED(15); IX_PF12 = PGMSPA.PF12_STACK.ZEIGER; $INCR(IX_PF12); IF IX_PF12 > $MAX_PF12 THEN do; CALL FEHLER(DUMMY0,'KS7413E'); $DECR(IX_PF12); end; PF12_STACK.REF_LINR(IX_PF12) = LINR; PF12_STACK.REF_ZEINR(IX_PF12) = ZEINR; PF12_STACK.REF_SEITNR(IX_PF12) = PGMSPA.Akt_SEITE; PGMSPA.PF12_STACK.ZEIGER = IX_PF12; RETURN(IX_PF12); END ADD_PF12_STACK; 1/********************************************************************/ /* */ /* S U B _ P F 1 2 _ S T A C K */ /* */ /********************************************************************/ /* die aktuelle referenz wird geloescht und die neue position */ /* zuruecgegeben (mit get ist der inhalt auszulesen) */ /* return : Zeiger auf aktuelle position im Stack */ /* */ /********************************************************************/ SUB_PF12_STACK: PROC RETURNS( BIN FIXED(15)) REORDER; DCL IX_PF12 BIN FIXED(15); IX_PF12 = PGMSPA.PF12_STACK.ZEIGER; PF12_STACK.REF_LINR(IX_PF12) = 0; PF12_STACK.REF_ZEINR(IX_PF12) = 0; PF12_STACK.REF_SEITNR(IX_PF12) = 0; $DECR(IX_PF12); $DECR(IX_PF12); PGMSPA.PF12_STACK.ZEIGER = IX_PF12; RETURN(IX_PF12+1); END SUB_PF12_STACK; 1/********************************************************************/ /* */ /* G E T _ P F 1 2 _ S E I T E */ /* */ /********************************************************************/ /* gibt die referenZ-Seitennumer von der aktuellen position zurueck */ /* (aktuelle position wird als parameter mitgegeben) */ /* return : referenz_seitennumer */ /* */ /********************************************************************/ GET_PF12_SEITE: PROC(ZEIGER) RETURNS( BIN FIXED(15)) REORDER; DCL ZEIGER BIN FIXED(15); DCL SEITNR BIN FIXED(15); DCL IX_PF12 BIN FIXED(15); IX_PF12 = ZEIGER; SEITNR = PF12_STACK.REF_SEITNR(IX_PF12); RETURN(SEITNR); END GET_PF12_SEITE; 1/********************************************************************/ /* */ /* G E T _ P F 1 2 _ Z E I L E */ /* */ /********************************************************************/ /* gibt die referen_zeilennummer von der aktuellen position zurueck */ /* (aktuelle position wird als parameter mitgegeben) */ /* return : referenz_zeilennumer */ /* */ /********************************************************************/ GET_PF12_ZEILE: PROC(ZEIGER) RETURNS( BIN FIXED(15)) REORDER; DCL ZEIGER BIN FIXED(15); DCL ZEINR BIN FIXED(15); DCL IX_PF12 BIN FIXED(15); IX_PF12 = ZEIGER; ZEINR = PF12_STACK.REF_ZEINR(IX_PF12); RETURN(ZEINR); END GET_PF12_ZEILE; 1/********************************************************************/ /* */ /* G E T _ P F 1 2 _ L I S T E */ /* */ /********************************************************************/ /* gibt die referen_zeilennummer von der aktuellen position zurueck */ /* (aktuelle position wird als parameter mitgegeben) */ /* return : referenz_zeilennumer */ /* */ /********************************************************************/ GET_PF12_LISTE: PROC(ZEIGER) RETURNS( BIN FIXED(15)) REORDER; /* IN-Parameter */ DCL ZEIGER BIN FIXED(15); /* Return-Parameter */ DCL LINR BIN FIXED(15); DCL IX_PF12 BIN FIXED(15); IX_PF12 = ZEIGER; LINR = PF12_STACK.REF_LINR(IX_PF12); RETURN(LINR); END GET_PF12_LISTE; 1/********************************************************************/ /* */ /* Funktion: aktualisiere Vertrag */ /* */ /********************************************************************/ /* speicher um in der PGMSPA : akt_ vertrag --> vor_vertrag */ /* : nxt_ vertrag --> akt_vertrag */ /* : 0 --> nxt_vertrag */ /* */ /********************************************************************/ AKTUAL_VERTRAG: PROC REORDER; PGMSPA.VOR_VERTRAG = PGMSPA.AKT_VERTRAG; PGMSPA.AKT_VERTRAG = PGMSPA.NXT_VERTRAG; PGMSPA.NXT_VERTRAG = 0; END AKTUAL_VERTRAG; 1/********************************************************************/ /* */ /* Funktion: aktualisiere Liste */ /* */ /********************************************************************/ /* speicher um in der PGMSPA : akt_ liste --> vor_liste */ /* : nxt_ liste --> akt_liste */ /* : 0 --> nxt_liste */ /* */ /********************************************************************/ AKTUAL_LISTE: PROC REORDER; PGMSPA.VOR_LISTE = PGMSPA.AKT_LISTE; PGMSPA.AKT_LISTE = PGMSPA.NXT_LISTE; PGMSPA.NXT_LISTE = 0; END AKTUAL_LISTE; 1/********************************************************************/ /* */ /* Funktion: aktualisiere pi_zeilen */ /* */ /********************************************************************/ /* speicher um in der PGMSPA : akt_ pi_zeile --> vor_pi_zeile */ /* : nxt_ pi_zeile --> akt_pi_zeile */ /* : 0 --> nxt_pi_zeile */ /* */ /********************************************************************/ AKTUAL_PI_ZEILE: PROC REORDER; PGMSPA.VOR_PI_ZEILE = PGMSPA.AKT_PI_ZEILE; PGMSPA.AKT_PI_ZEILE = PGMSPA.NXT_PI_ZEILE; PGMSPA.NXT_PI_ZEILE = 0; END AKTUAL_PI_ZEILE; 1/********************************************************************/ /* */ /* Funktion: aktualisiere histnr */ /* */ /********************************************************************/ /* speicher um in der PGMSPA : akt_ histnr --> vor_histnr */ /* : nxt_ histnr --> akt_histnr */ /* : 0 --> nxt_histnr */ /* */ /********************************************************************/ AKTUAL_HISTNR: PROC REORDER; PGMSPA.VOR_HISTNR = PGMSPA.AKT_HISTNR; PGMSPA.AKT_HISTNR = PGMSPA.NXT_HISTNR; PGMSPA.NXT_HISTNR = 0; END AKTUAL_HISTNR; 1/********************************************************************/ /* */ /* Funktion: aktualisiere aenddt */ /* */ /********************************************************************/ /* speicher um in der PGMSPA : akt_ aenddt --> vor_aenddt */ /* : nxt_ aenddt --> akt_aenddt */ /* : 0 --> nxt_aenddt */ /* */ /********************************************************************/ AKTUAL_AENDDT: PROC REORDER; PGMSPA.VOR_AENDDT = PGMSPA.AKT_AENDDT; PGMSPA.AKT_AENDDT = PGMSPA.NXT_AENDDT; PGMSPA.NXT_AENDDT = 0; END AKTUAL_AENDDT; 1/********************************************************************/ /* */ /* Funktion: aktualisiere objekt */ /* */ /********************************************************************/ /* speicher um in der PGMSPA : akt_ objekt --> vor_objekt */ /* : nxt_ objekt --> akt_objekt */ /* : 0 --> nxt_objekt */ /* */ /********************************************************************/ AKTUAL_OBJEKT: PROC REORDER; PGMSPA.VOR_OBJEKT = PGMSPA.AKT_OBJEKT; PGMSPA.AKT_OBJEKT = PGMSPA.NXT_OBJEKT; PGMSPA.NXT_OBJEKT = 0; END AKTUAL_OBJEKT; 1/********************************************************************/ /* */ /* fuelle - statistik - objekt */ /* */ /********************************************************************/ FUELLE_STAT_VTR: PROC REORDER; DCL VANZ_PIC PIC 'Z9'; DCL VVON_PIC PIC 'Z9'; DCL VBIS_PIC PIC 'Z9'; VANZ_PIC = PGMSPA.ANZ_VERTRAEGE; VVON_PIC = PGMSPA.AKT_V_LFDNR; VBIS_PIC = PGMSPA.AKT_V_LFDNR; KS074DA.VVON = VVON_PIC; KS074DA.VBIS = VBIS_PIC; KS074DA.VANZ = VANZ_PIC; END FUELLE_STAT_VTR; 1/********************************************************************/ /* */ /* fuelle - statistik - objekt */ /* */ /********************************************************************/ FUELLE_STAT_OBJ: PROC (START, ANZAHL) REORDER; /* IN - PARAMETER */ DCL START BIN FIXED(15); DCL ANZAHL BIN FIXED(15); /* LOKALE VARIABLE */ DCL POS BIN FIXED(15); DCL I BIN FIXED(15); DCL OANZ_PIC PIC 'Z9'; DCL OVON_PIC PIC 'Z9'; DCL OBIS_PIC PIC 'Z9'; OANZ_PIC = PGMSPA.ANZ_OBJEKTE; OVON_PIC = ' 0'; OBIS_PIC = ' 0'; DO I = 1 TO ANZAHL; POS = START + I; IF ZEILEN_TAB.ONR(POS) > 0 THEN DO; IF OVON_PIC = ' 0' THEN OVON_PIC = ZEILEN_TAB.ONR(POS); IF OBIS_PIC ^= ZEILEN_TAB.ONR(POS) THEN OBIS_PIC = ZEILEN_TAB.ONR(POS); END; END; KS074DA.OVON = OVON_PIC; KS074DA.OBIS = OBIS_PIC; KS074DA.OANZ = OANZ_PIC; END FUELLE_STAT_OBJ; 1/********************************************************************/ /* */ /* UNTERPROGRAMM: L E N */ /* */ /********************************************************************/ /* KURZE FUNKTIONSBESCHREIBUNG */ /* - ERMITTELT DIE LÄNGE EINES STRINGS OHNE NACHFOLGENDE BLANKS */ /* */ /********************************************************************/ LEN: PROC( STR ) RETURNS( BIN FIXED(15) ); DCL STR CHAR(*); DCL L_J BIN FIXED(15); DO L_J = LENGTH( STR ) TO 1 BY -1 WHILE( SUBSTR( STR, L_J, 1 ) = ' ' ); END; RETURN( L_J ); END LEN; 1/********************************************************************/ /* */ /* GET _ VTRJOUR _ VTRKATKZ */ /* */ /*------------------------------------------------------------------*/ /* liest aus der pgm_schwebe die aktuelle liste in die struktur */ /* auskunft */ /* */ /********************************************************************/ GET_VTRJOUR_VTRKATKZ: PROC (VSNR, VTRNR) RETURNS(DEC FIXED(3,0)) REORDER; /* IN_PARAMETER */ DCL VSNR CHAR (10); DCL VTRNR DEC FIXED(15,0); /* RETURN_PARAMETER */ DCL VTRKATKZ DEC FIXED(3,0); /* RUMPF_BEGINN */ DCLTBKO_VTRJOURNAL.VSNR = VSNR; DCLTBKO_VTRJOURNAL.VTRNR = VTRNR; call DB2(40); IF SQLCA.SQLCODE = 0 then VTRKATKZ = DCLTBKO_VTRJOURNAL.VTRKATKZ; ELSE VTRKATKZ = 331.0; RETURN(VTRKATKZ); END GET_VTRJOUR_VTRKATKZ; /********************************************************************/ /* ENDE MKS0074 */ /********************************************************************/ END MKS0074; /*------------------------------------------------------------------*/ /* [nderungen bei Verwendung: */ /* */ /* - Transaktions/Bild/Programme: */ /* z.B. für KS43: C ALL KS99 KS74 */ /* C ALL KS099 KS074 */ /* C ALL MKS0099 MKS0074 */ /* - Transaktionsspezifisch: */ /* Alle anzupassenden Stellen sind mit $$$ und einer Beschreibung */ /* der notwendigen/optionalen Anpassung gekennzeichnet. */ /* */ /* - MOD-Strukturname KS074DA */ /* Erwartete Felder: */ /* PERSNR */ /* VARTBZ */ /* BENUMELD */ /* VSNR */ /* BEARBNR * wenn vtrnr bekannt durch */ /* PERSNRN * MKS1314 */ /* HISTNRN * MKS1315 */ /* AENDDTN * */ /* BEARDTN * */ /* BEARSTN * */ /* VTBGDTN * */ /* VONZEIL * wenn liste bekannt durch */ /* BISZEIL * MKS1315 */ /* ANZZEIL * Hole_Akt_Liste */ /* TRAN */ /* ORDBGR */ /* CMD */ /* - MID-Strukturname KS074DE */ /* Erwartete Felder: */ /* TRAN */ /* ORDBGR */ /* CMD */ /* Aktion * kann Eingaben enthalten */ /* */ /*------------------------------------------------------------------*/ /* */ /* .---------------------. */ /**---------------------! UNTERPROGRAMME !--------------------**/ /* '---------------------' */ /* (Abweichungen vom Bildmodulstandard mit '*' kennzeichnen !) */ /* */ /* BIBLIOTHEKEN: */ /* ============= */ /* Macros: */ /* ------- */ /* $KQTRAN - Funktionen f}r MKO3099 (TS_*) */ /* -> MKO3099 - Transaktionssteuerung */ /* $KQROUT - Allg. PL/I-Funktionen */ /* $KQMACRO - Allg. PL/I-Macros */ /* $KQONL - Allg. Funktionen/Macros Bildmodule */ /* KQ$BILD - Konstanten f}r Bildmodule */ /* SMKV0007 - Handle_SPA */ /* BUILTIN2 - Standard_Macros */ /* DB2SQLCA - DB2_Fehlermeldungen */ /* */ /* Strukturen: */ /* ----------- */ /* KS074D - Bild_Struktur MID, MOD */ /* SDC005DC - Schnittstelle des Bildmoduls gesamt */ /* X2000513 - */ /* SDP110DC - */ /* SDC003DC - DC_MID, DC_MOD (u.a. Taste) */ /* SDP001DC - */ /* SKOSPA - gesamte SPA */ /* SKSSPAP - Projekt_SPA */ /* SKSSPAL - Lokale SPA */ /* */ /* Programmteile: */ /* -------------- */ /* SKOCUAD8 */ /* SKOABBR8 */ /* */ /* EXTERN: */ /* ======= */ /* */ /* MKO0997 - Abbruchbild Kompass */ /* MKO3066 - Aufbau Kopfdaten */ /* MKO5038 - IO-Modul TBKO_MELDUNGEN */ /* MKO5096 - IO-Modul TBKO_KON_PGM_TXT */ /* MKQ6100 - Verwaltung TBKO_PGM_SCHWEBE */ /* */ /* */ /* INTERN: */ /* ======= */ /* */ /* STEUERUNG: */ /* ---------- */ /* GRUNDWERTE - Initialisierungen je Aufruf */ /* ERSTAUFRUF - Initialisierungen vor/zur ersten Anzeige */ /* FOLGEAUFRUF - Steuerung des Folgeaufrufs, */ /* Verteilung abh. von gedr. Taste */ /* VERARB_ENTER - -Verarbeitung: Plausi,Verarbeitung,*/ /* n{chste Transaktion */ /* AKTUALISIERE - -Verarbeitung : Plausi,Verarbeitung */ /* HISTBL_RUECK - Historisches R}ckw{rtsbl{ttern */ /* HISTBL_VOR - Historisches Vorw{rtsbl{ttern */ /* BL_RUECK - Zeilentabelle nach oben bl{ttern */ /* BL_VOR - Zeilentabelle nach unten bl{ttern */ /* SCHWEBE_BEARBEITUNG - Gibt zur}ck, ob in Schwebeverarbeitung */ /* MELDEN_BEARBEITET - 'Bearbeitet' an Transaktionssteuerung */ /* melden und n{chste Trans. ermitteln */ /* ENDE_ROUTINE - MOD-Aufbereitungen/Aufr{umarbeiten */ /* ---------------------- spezielle Anpassungen/Erg{nzungen */ /* ermittle_Folgeliste - ermitteln der n{chste anzuzeigenden */ /* Liste */ /* */ /* FACHL./ANW.SPEZ.FUNKTIONEN: */ /* --------------------------- */ /* EINGABE_OK - Formale Plausi der Eingaben */ /* VERARBEITUNG - Fachl. Verarbeitung der Eingaben */ /* LESE_ZEILEN_TAB - Lesen der anzuzeigenden Zeilen */ /* LESE_HINWEISE - Lesen der anzuzeigenden Hinweise */ /* */ /* MID/MOD-VERWALTUNG: */ /* ------------------- */ /* KOPFDATEN - Kopfdaten der Maske ermitteln */ /* AUFBAU_MOD - MOD komplett neu aufbauen */ /* ANZEIGE_MOD - MOD f}r Anzeige aufbereiten */ /* ATTRIBUTE - Setzen der Feldattribute gem. Vorgang */ /* MID_MOD - MOD zur Verarbeitung aus MID aufbauen */ /* (bei Folgeverarbeitung) */ /* MID_MOD_AENDERUNG - Pr}fung, ob Eingaben gemacht wurden */ /* MOD_ZEILEN_TAB - MOD in ZEILEN_TAB kopieren (Eingaben) */ /* ZEILEN_TAB_MOD - ZEILEN_TAB in MOD kopieren zur Anzeige */ /* ---------------------- spezielle Anpassungen/Erg{nzungen */ /* Erstmaske - Datenbereitstellung f}r den Erstaufruf */ /* Folgemaske - Datenbereitstellung f}r alle Folgeaufrufe */ /* */ /* TECHN.FUNKTIONEN: */ /* ----------------- */ /* PGM_SCHWEBE - Laden/Sichern TBKS_PGM_SCHWEBE */ /* LESE_MELDUNG - Lesen aus TBKO_MELDUNGEN }ber MELD_ID */ /* LESE_PGMTEXT - Lesen aus TBKO_KON_PGM_TXT */ /* TS_FEHLER - Fehlerabhandlung f}r $KQTRAN */ /* GET_MAIN - Dyn. ben¦tigten Speicher allokieren */ /* FREE_MAIN - Dyn. ben¦tigten Speicher freigeben */ /* RESTORE - Stackverarbeitung (analog Kompass) */ /* */ /*------------------------------------------------------------------*/