commit b2304afa4b48c960bd09437fd0a6ef72591d0cfb Author: Christian Albers Date: Fri Jun 14 10:39:14 2024 +0200 Initialer Upload diff --git a/Kleeberg/20_value_sets.groovy b/Kleeberg/20_value_sets.groovy new file mode 100644 index 0000000..333e681 --- /dev/null +++ b/Kleeberg/20_value_sets.groovy @@ -0,0 +1,1225 @@ + +// Global d.3 libraries ----------------------------------------------------- +import com.dvelop.d3.server.core.D3Interface; +import com.dvelop.d3.server.Document; +import com.dvelop.d3.server.User; +import com.dvelop.d3.server.DocumentType; + +// Libraries to handle the different hook types ----------------------------- +import com.dvelop.d3.server.ValueSet; + +// Special libraries -------------------------------------------------------- +import com.dvelop.d3.server.RepositoryField; + + + +class ValueSetsCombined { + + @ValueSet( entrypoint = "WM_DAOberRegister" ) + def WM_DAOberRegister ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 3 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + def wm_typ = ""; + def unterreg = ""; + + switch ( docType.id ) + { + case "AUREG": + case "AURG2": + case "AURG3": + case "AOREG": + case "AREGS": + case "DDAUE": + wm_typ = "Dauerakte%"; + break; + case "AJAOB": + case "AJAAB": + case "DABSC": + case "AJAUR": + case "AJAU2": + wm_typ = "Jahresabschlussakte%"; + break; + case "DBERA": + case "ABERO": + case "ABERA": + case "ABEUR": + case "ABEU2": + wm_typ = "Beratungsakte%"; + break; + case "DSTEU": + case "ASTOR": + case "ASTRA": + case "ASTUR": + case "ASTU2": + wm_typ = "Steuerakte%"; + break; + case "DBETR": + case "ABEPA": + case "ABEOR": + case "ABPUR": + case "ABPU2": + wm_typ = "Betriebspruefungsakte%"; + break; + case "DFIBU": + case "AFIOR": + case "AFIRA": + case "AFIUR": + case "AFIU2": + wm_typ = "Fibuakte%"; + break; + case "DLOHN": + case "ALBOR": + case "ALBRE": + case "ALJUR": + case "ALJR2": + wm_typ = "Lohnbuchhaltungjahresakte%"; + break; + case "DLSTD": + case "ALBSO": + case "ALORE": + case "ALOUR": + case "ALBU2": + wm_typ = "Lohnbuchhaltungsstammdatenakte%"; + break; + case "DDEBD": + case "AAURR": + case "AAURU": + case "AAURA": + case "AAUR2": + wm_typ = "Ausgangsrechnungsakte%"; + break; + case "AKROR": + case "AKRER": + case "AKREU": + case "AKRU2": + case "DKRED": + wm_typ = "Kreditorenakte%"; + break; + case "DUMMY": + case "ADUMY": + case "DDUMY": + wm_typ = "%"; + break; + + } + + def sqlQuery = "select distinct top (10000) dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 like '" + wm_typ + "' order by dok_dat_feld_2 "; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_2 } ); + } + } + + + @ValueSet( entrypoint = "WM_DARegister" ) + def WM_DARegister ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 4 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + + def wm_typ = ""; + + switch ( docType.id ) + { + case "AUREG": + case "AURG2": + case "AURG3": + case "DDAUE": + wm_typ = "Dauerakte%"; + break; + case "AJAOB": + case "AJAAB": + case "DABSC": + case "AJAUR": + case "AJAU2": + wm_typ = "Jahresabschlussakte%"; + break; + case "DBERA": + case "ABERO": + case "ABERA": + case "ABEUR": + case "ABEU2": + wm_typ = "Beratungsakte%"; + break; + case "DSTEU": + case "ASTOR": + case "ASTRA": + case "ASTUR": + case "ASTU2": + wm_typ = "Steuerakte%"; + break; + case "DBETR": + case "ABEPA": + case "ABEOR": + case "ABPUR": + case "ABPU2": + wm_typ = "Betriebspruefungsakte%"; + break; + case "DFIBU": + case "AFIOR": + case "AFIRA": + case "AFIUR": + case "AFIU2": + wm_typ = "Fibuakte%"; + break; + case "DLOHN": + case "ALBOR": + case "ALBRE": + case "ALJUR": + case "ALJR2": + wm_typ = "Lohnbuchhaltungjahresakte%"; + break; + case "DLSTD": + case "ALBSO": + case "ALOUR": + case "ALBU2": + wm_typ = "Lohnbuchhaltungsstammdatenakte%"; + break; + case "DDEBD": + case "AAURR": + case "AAURU": + case "AAUR2": + wm_typ = "Ausgangsrechnungsakte%"; + break; + case "DKRED": + case "AKROR": + wm_typ = "Kreditorenakte%"; + break; + case "DUMMY": + case "AOREG": + case "AREGS": + wm_typ = "%"; + break; + + } + + def where = ""; + def where2 = ""; + + if ( doc.field[ 3 ] != null ) + { + where = " and dok_dat_feld_2 = '" + doc.field[ 3 ] + "'"; + } + + if ( doc.field[ 1 ] != null ) + { + where2 = " and dok_dat_feld_1 = '" + doc.field[ 1 ] + "' "; + } + + if ( doc.field[ 10 ] ) + { + where2 = where2 + " and dok_dat_feld_10 = '" + doc.field[ 10 ] + "' "; + } + + def sqlQuery = "select distinct top (10000) dok_dat_feld_3 as ddf3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 like '" + wm_typ + "' " + where + " union select distinct dok_dat_feld_4 as ddf3 from firmen_spezifisch where kue_dokuart in ('ABERA', 'ABEPA', 'AREGS', 'AFIRA', 'AJAAB', 'ALBRE', 'ALORE', 'ASTRA', 'AKRER' ) " + where2 + " and dok_dat_feld_4 != '' and dok_dat_feld_4 is not null and dok_dat_feld_4 not in (select dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_3 is not null ) and dok_dat_feld_4 not in ( select dok_dat_feld_4 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_4 is not null ) order by ddf3"; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.ddf3 } ); + } + + } + + + @ValueSet( entrypoint = "WM_DAUnterRegister" ) + def WM_DAUnterRegister ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 23 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + + // Es wird geprüft, ob das Register innerhalb des Mandanten (DDF1=>Mandant-Nr.) unterhalb des jetzt verwendeten Registers (DDF4) + // angelegt wurde. + + def such_dokart, where = ""; + + switch ( docType.id ) + { + case "AUREG": + case "AURG2": + case "AURG3": + case "DDAUE": + such_dokart = "AUREG"; + break; + case "DABSC": + case "AJAUR": + case "AJAU2": + such_dokart = "AJAUR"; + break; + case "DBERA": + case "ABEUR": + case "ABEU2": + such_dokart = "ABEUR"; + break; + case "DSTEU": + case "ASTUR": + case "ASTU2": + such_dokart = "ASTUR"; + break; + case "DBETR": + case "ABPUR": + case "ABPU2": + such_dokart = "ABPUR"; + break; + case "DFIBU": + case "AFIUR": + case "AFIU2": + such_dokart = "AFIUR"; + break; + case "DLOHN": + case "ALJUR": + case "ALJR2": + such_dokart = "ALJUR"; + break; + case "DLSTD": + case "ALOUR": + case "ALBU2": + such_dokart = "ALOUR"; + break; + case "DDEBD": + case "AAURU": + case "AAUR2": + such_dokart = "AAURU"; + break; + case "DKRED": + case "AKREU": + case "AKRU2": + such_dokart = "ABEUR"; + break; + + } + + if ( doc.field[ 1 ] ) + { + where = " and dok_dat_feld_1 = '" + doc.field[ 1 ] + "' "; + } + + if ( doc.field[ 10 ] ) + { + where = where + " and dok_dat_feld_10 = '" + doc.field[ 10 ] + "' "; + } + + + def sqlQuery = "select distinct top (10000) dok_dat_feld_23 from firmen_spezifisch \ + where kue_dokuart in ( '" + such_dokart + "' ) \ + and dok_dat_feld_23 != '' \ + and dok_dat_feld_4 = '" + doc.field[ 4 ] + "' " + where; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_23 } ); + } + + } + + + @ValueSet( entrypoint = "WM_DAUnterRegister2" ) + def WM_DAUnterRegister2( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 17 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + + // Es wird geprüft, ob das Register innerhalb des Mandanten (DDF1=>Mandant-Nr.) unterhalb des jetzt verwendeten Registers (DDF4) + // angelegt wurde. + + def such_dokart, where = ""; + + switch ( docType.id ) + { + case "AURG2": + case "AURG3": + case "DDAUE": + such_dokart = "AURG2"; + break; + case "DABSC": + case "AJAU2": + such_dokart = "AJAU2"; + break; + case "DBERA": + case "ABEU2": + such_dokart = "ABEU2"; + break; + case "DSTEU": + case "ASTU2": + such_dokart = "ASTU2"; + break; + case "DBETR": + case "ABPU2": + such_dokart = "ABPU2"; + break; + case "DFIBU": + case "AFIU2": + such_dokart = "AFIU2"; + break; + case "DLOHN": + case "ALJR2": + such_dokart = "ALJR2"; + break; + case "DLSTD": + case "ALBU2": + such_dokart = "ALBU2"; + break; + case "DDEBD": + case "AAUR2": + such_dokart = "AAUR2"; + break; + case "DKRED": + case "AKRU2": + such_dokart = "AKRU2"; + break; + + } + + + if ( doc.field[ 1 ] ) + { + where = " and dok_dat_feld_1 = '" + doc.field[ 1 ] + "' "; + } + + if ( doc.field[ 10 ] ) + { + where = where + " and dok_dat_feld_10 = '" + doc.field[ 10 ] + "' "; + } + + def sqlQuery = "select distinct top (10000) dok_dat_feld_17 from firmen_spezifisch \ + where kue_dokuart in ( '" + such_dokart + "' ) \ + and dok_dat_feld_17 != '' \ + and dok_dat_feld_23 = '" + doc.field[ 23 ] + "' " + where; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_17 } ); + } + + } + + + @ValueSet( entrypoint = "WM_DAUnterRegister3" ) + def WM_DAUnterRegister3( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 32 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + // Es wird geprüft, ob das Register innerhalb des Mandanten (DDF1=>Mandant-Nr.) unterhalb des jetzt verwendeten Registers (DDF4) + // angelegt wurde. + + def where = ""; + + if ( doc.field[ 1 ] ) + { + where = " and dok_dat_feld_1 = '" + doc.field[ 1 ] + "' "; + } + + if ( doc.field[ 10 ] ) + { + where = where + " and dok_dat_feld_10 = '" + doc.field[ 10 ] + "' "; + } + + def sqlQuery = "select distinct top (10000) dok_dat_feld_32 from firmen_spezifisch \ + where kue_dokuart in ( 'AURG3' ) \ + and dok_dat_feld_32 != '' \ + and dok_dat_feld_17 = '" + doc.field[ 17 ] + "' " + where; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_32 } ); + } + + } + + + @ValueSet( entrypoint = "WM_Aktennummer" ) + def WM_Aktennummer ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 10 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + + def where = ""; + def kuerzel = ""; + + def mandant_oder_kreditor; + def dokuarten; + + switch ( docType.id ) + { + case "DDAUE": // Dauerakte + case "AUREG": + case "AURG2": + case "AURG3": + case "AOREG": + case "AREGS": + case "ADAUR": + mandant_oder_kreditor = 0; + kuerzel = "DA"; + break; + case "DABSC": // Jahresabschlussakte + case "AJAAA": + case "AJAOB": + case "AJAAB": + case "AJAUR": + case "AJAU2": + mandant_oder_kreditor = 0; + kuerzel = "JA"; + break; + case "DBERA": // Beratungsakte + case "ABERB": + case "ABERO": + case "ABERA": + case "ABEUR": + case "ABEU2": + mandant_oder_kreditor = 0; + kuerzel = "BE"; + break; + case "DSTEU": // Steuerakte + case "ASTEU": + case "ASTOR": + case "ASTRA": + case "ASTUR": + case "ASTU2": + mandant_oder_kreditor = 0; + kuerzel = "ST"; + break; + case "DBETR": // Betriebspruefungsakte + case "ABETR": + case "ABEPA": + case "ABEOR": + case "ABPUR": + case "ABPU2": + mandant_oder_kreditor = 0; + kuerzel = "BP"; + break; + case "DFIBU": // Fibuakte + case "AFIBA": + case "AFIOR": + case "AFIRA": + case "AFIUR": + case "AFIU2": + mandant_oder_kreditor = 0; + kuerzel = "FI"; + break; + case "DLOHN": // Lohnbuchhaltungjahresakte + case "ALOJA": + case "ALBOR": + case "ALBRE": + case "ALJUR": + case "ALJR2": + mandant_oder_kreditor = 0; + kuerzel = "LO"; + break; + case "DLSTD": // Lohnbuchhaltungsstammdatenakte + case "ALBSA": + case "ALBSO": + case "ALORE": + case "ALOUR": + case "ALBU2": + mandant_oder_kreditor = 0; + kuerzel = "LS"; + break; + case "DDEBD": // Ausgangsrechnungsakte + case "AAURE": + case "AAURR": + case "AAURA": + case "AAURU": + case "AAUR2": + mandant_oder_kreditor = 0; + kuerzel = "RE"; + break; + case "AKRED": // Kreditorenakte + case "AKROR": + case "AKRER": + case "AKREU": + case "AKRU2": + case "DKRED": + mandant_oder_kreditor = 1; + kuerzel = "KA"; + break; + case "AEVAK": // Eigenverwaltungsakte + case "AEVOR": + case "AEVRE": + case "DEVDO": + mandant_oder_kreditor = 2; + kuerzel = "EV"; + break; + } + + switch ( mandant_oder_kreditor ) + { + case 0: + if ( doc.field[ 2 ] ) + { + where = " and dok_dat_feld_2 = '" + doc.field[ 2 ] + "' "; + } + if ( doc.field[ 1 ] ) + { + where = " and dok_dat_feld_1 = '" + doc.field[ 1 ] + "' "; + } + dokuarten = "'DBERA', 'DBETR', 'DDAUE', 'DDEBD', 'DFIBU', 'DABSC', 'DLOHN', 'DLSTD', 'DSTEU', 'ABERB', 'AAURE', 'ABETR', 'ADAUR', 'AFIBA', 'AJAAA', 'AKRED', 'ALOJA', 'ALBSA', 'ASTEU'"; + break; + case 1: + if ( doc.field[ 20 ] ) + { + where = " and dok_dat_feld_20 = '" + doc.field[ 20 ] + "' "; + } + if ( doc.field[ 19 ] ) + { + where = " and dok_dat_feld_19 = '" + doc.field[ 19 ] + "' "; + } + dokuarten = "'DKRED', 'AKRED'" + break; + case 2: + dokuarten = "'AEVAK', 'DEVDO'" + break; + + } + + if ( doc.field[ 21 ] ) + { + where = where + " and dok_dat_feld_21 = '" + doc.field[ 21 ] + "' "; + } + + where = where + " and dok_dat_feld_10 like '%" + kuerzel + "%' "; + + def sqlQuery = "select distinct top (10000) dok_dat_feld_10 from firmen_spezifisch where kue_dokuart in ( " + dokuarten + " ) " + where; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_10 } ); + } + } + + + @ValueSet( entrypoint = "WM_MandantNummer" ) + def WM_MandantNummer ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 1 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + def where = ""; + def sqland = ""; + + if ( doc.field[ 2 ] ) + { + where = " where clientname = '" + doc.field[ 2 ].toString().replace( "\'", "''" ) + "' "; + } + + if ( doc.field[ 13 ] ) + { + if ( where.length() > 0 ) + { + sqland = " and "; + } + else + { + sqland = " where "; + } + where = where + sqland + " client_group_number = '" + doc.field[ 13 ] + "' "; + } + + def sqlQuery = "select distinct top (10000) number from DatevClients " + where; + + //d3.log.error( "SQLQUERY WM " + sqlQuery ); + + def sql = groovy.sql.Sql.newInstance( "jdbc:sqlserver://kp-sql01\\D3;databaseName=D3P_Datev", 'd3_master', 'Xbn8"Ep4', 'com.microsoft.sqlserver.jdbc.SQLServerDriver' ); + + def rows = sql.rows( sqlQuery ); + + if ( rows.size() > 0 ) + { + reposField.provideValuesForValueSet( rows.collect{ it.number } ); + } + + sql.close(); + } + + + @ValueSet( entrypoint = "WM_MandantName" ) + def WM_MandantName ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 2 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + + def where = ""; + def sqland = ""; + + if ( doc.field[ 1 ] ) + { + where = " where number = '" + doc.field[ 1 ] + "' "; + } + + + if ( doc.field[ 13 ] ) + { + if ( where.length() > 0 ) + { + sqland = " and "; + } + else + { + sqland = " where "; + } + where = where + sqland + " client_group_number = '" + doc.field[ 13 ] + "' "; + } + + + def sqlQuery = "select distinct top (10000) clientname from DatevClients " + where; + + def sql = groovy.sql.Sql.newInstance( "jdbc:sqlserver://kp-sql01\\D3;databaseName=D3P_Datev", 'd3_master', 'Xbn8"Ep4', 'com.microsoft.sqlserver.jdbc.SQLServerDriver' ); + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + def rows = sql.rows( sqlQuery ); + + if ( rows.size() > 0 ) + { + reposField.provideValuesForValueSet( rows.collect{ it.clientname } ); + } + + sql.close(); + + } + + + @ValueSet( entrypoint = "WM_MandantGruppenNummer" ) + def WM_MandantGruppenNummer ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 13 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + + def where = ""; + + if ( doc.field[ 1 ] ) + { + where = " and dok_dat_feld_1 = '" + doc.field[ 1 ] + "' "; + } + + if ( doc.field[ 10 ] ) + { + def mandantnr = doc.field[ 10 ].substring( 0, 5 ); + where = " and dok_dat_feld_1 = '" + mandantnr + "' "; + } + + // Der Mandantname wird nur mit einbezogen, wenn Mandantnummer oder Aktennummer (wo die Mandant-Nr. enthalten ist) nicht angegeben sind. + if ( ( doc.field[ 2 ] ) && ( ! ( doc.field[ 1 ] || doc.field[ 10 ] ) ) ) + { + where = where + " and dok_dat_feld_2 = '" + doc.field[ 2 ].toString().replace( "\'", "''" ) + "' "; + } + + + def sqlQuery = "select distinct top (10000) dok_dat_feld_13 from firmen_spezifisch where kue_dokuart in ( 'AMAND' ) " + where; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_13 } ); + } + else + { + reposField.provideValuesForValueSet( [''] ); + } + + } + + + @ValueSet( entrypoint = "WM_AktenName" ) + def WM_AktenName ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 21 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + + def where = ""; + def kuerzel = ""; + + def mandant_oder_kreditor; + def dokuarten; + + switch ( docType.id ) + { + case "DDAUE": // Dauerakte + case "AUREG": + case "AURG2": + case "AURG3": + case "AOREG": + case "AREGS": + case "ADAUR": + dokuarten = "'DDAUE', 'ADAUR'"; + mandant_oder_kreditor = 0; + kuerzel = "DA"; + break; + case "DABSC": // Jahresabschlussakte + case "AJAAA": + case "AJAOB": + case "AJAAB": + case "AJAUR": + case "AJAU2": + dokuarten = "'DABSC', 'AJAAA'"; + mandant_oder_kreditor = 0; + kuerzel = "JA"; + break; + case "DBERA": // Beratungsakte + case "ABERB": + case "ABERO": + case "ABERA": + case "ABEUR": + case "ABEU2": + dokuarten = "'DBERA', 'ABERB'"; + mandant_oder_kreditor = 0; + kuerzel = "BE"; + break; + case "DSTEU": // Steuerakte + case "ASTEU": + case "ASTOR": + case "ASTRA": + case "ASTUR": + case "ASTU2": + dokuarten = "'DSTEU', 'ASTEU'"; + mandant_oder_kreditor = 0; + kuerzel = "ST"; + break; + case "DBETR": // Betriebspruefungsakte + case "ABETR": + case "ABEPA": + case "ABEOR": + case "ABPUR": + case "ABPU2": + dokuarten = "'DBETR', 'ABETR'"; + mandant_oder_kreditor = 0; + kuerzel = "BP"; + break; + case "DFIBU": // Fibuakte + case "AFIBA": + case "AFIOR": + case "AFIRA": + case "AFIUR": + case "AFIU2": + dokuarten = "'DFIBU', 'AFIBA'"; + mandant_oder_kreditor = 0; + kuerzel = "FI"; + break; + case "DLOHN": // Lohnbuchhaltungjahresakte + case "ALOJA": + case "ALBOR": + case "ALBRE": + case "ALJUR": + case "ALJR2": + dokuarten = "'DLOHN', 'ALOJA'"; + mandant_oder_kreditor = 0; + kuerzel = "LO"; + break; + case "DLSTD": // Lohnbuchhaltungsstammdatenakte + case "ALBSA": + case "ALBSO": + case "ALORE": + case "ALOUR": + case "ALBU2": + dokuarten = "'DLSTD', 'ALBSA'"; + mandant_oder_kreditor = 0; + kuerzel = "LS"; + break; + case "DDEBD": // Ausgangsrechnungsakte + case "AAURE": + case "AAURR": + case "AAURA": + case "AAURU": + case "AAUR2": + dokuarten = "'DDEBD', 'AAURE'"; + mandant_oder_kreditor = 0; + kuerzel = "RE"; + break; + case "AKRED": // Kreditorenakte + case "AKROR": + case "AKRER": + case "AKREU": + case "AKRU2": + case "DKRED": + dokuarten = "'DKRED', 'AKRED'"; + mandant_oder_kreditor = 1; + kuerzel = "KA"; + break; + case "AEVAK": // Eigenverwaltungsakte + case "AEVOR": + case "AEVRE": + case "DEVDO": + dokuarten = "'AEVAK', 'DEVDO'"; + mandant_oder_kreditor = 2; + kuerzel = "EV"; + break; + } + + switch ( mandant_oder_kreditor ) + { + case 0: + if ( doc.field[ 2 ] ) + { + where = " and dok_dat_feld_2 = '" + doc.field[ 2 ] + "' "; + } + if ( doc.field[ 1 ] ) + { + where = " and dok_dat_feld_1 = '" + doc.field[ 1 ] + "' "; + } + break; + case 1: + if ( doc.field[ 20 ] ) + { + where = " and dok_dat_feld_20 = '" + doc.field[ 20 ] + "' "; + } + if ( doc.field[ 19 ] ) + { + where = " and dok_dat_feld_19 = '" + doc.field[ 19 ] + "' "; + } + break; + case 2: + if ( doc.field[ 21 ] ) + { + where = " and dok_dat_feld_21 = '" + doc.field[ 21 ] + "' "; + } + break; + + } + + if ( doc.field[ 10 ] ) + { + where = where + " and dok_dat_feld_10 = '" + doc.field[ 10 ] + "' "; + } + + + + + def sqlQuery = "select distinct top (10000) dok_dat_feld_21 from firmen_spezifisch where kue_dokuart in ( " + dokuarten + " ) " + where; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_21 } ); + } + + } + + + @ValueSet( entrypoint = "WM_Grundstueck" ) + def WM_Grundstueck ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + // Feststellen der Mandantennummer + // Feststellen der Doku-ID der Akte "04.01 Grundstücke" zu diesem Mandanten + // Ermitteln der Grundstückseinträge in dieser Akte + // Anbieten als Wertemenge + + // Ohne Mandantennummer keine Werte! + def mandantnr; + + if ( doc.field[ 1 ] ) + { + mandantnr = doc.field[ 1 ]; + } + else + { + mandantnr = doc.field[ 10 ].substring( 0, 5 ); + } + //d3.log.info( "gefundene mandantnr " + mandantnr ); + if ( mandantnr ) + { + def sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = 'AREGS' and dok_dat_feld_4 like '04.01 Grundst_cke' and dok_dat_feld_1 = '" + doc.field[ 1 ] + "' order by doku_id desc"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + //d3.log.info( "resultRows size: " + resultRows.size() ); + + if ( resultRows.size() > 0 ) + { + def doku_id = resultRows[ 0 ].doku_id; + //d3.log.info( "gefundene Doku-ID " + doku_id ); + sqlQuery = "select top (10000) value_char from firm_spez_mult_val where doku_id = '" + doku_id + "' and field_no = 68 "; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.value_char } ); + } + } + } + } + + + @ValueSet( entrypoint = "WM_KreditorName" ) + def WM_KreditorName ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 20 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + + def where = ""; + + if ( doc.field[ 19 ] ) + { + where = " and dok_dat_feld_19 = '" + doc.field[ 19 ] + "' "; + } + + if ( doc.field[ 10 ] ) + { + def krednr = doc.field[ 10 ].substring( 0, 5 ); + where = where + " and dok_dat_feld_19 = '" + krednr + "' "; + } + + + def sqlQuery = "select distinct top (10000) dok_dat_feld_20 from firmen_spezifisch where kue_dokuart in ( 'AKRED' ) " + where; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_20 } ); + } + + } + + + @ValueSet( entrypoint = "WM_KreditorNummer" ) + def WM_KreditorNummer ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 19 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + + + def where = ""; + + if ( doc.field[ 20 ] ) + { + where = " and dok_dat_feld_20 = '" + doc.field[ 20 ] + "' "; + } + + if ( doc.field[ 10 ] ) + { + def krednr = doc.field[ 10 ].substring( 0, 5 ); + where = where + " and dok_dat_feld_19 = '" + krednr + "' "; + } + + + def sqlQuery = "select distinct top (10000) dok_dat_feld_19 from firmen_spezifisch where kue_dokuart in ( 'AKRED' ) " + where; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_19 } ); + } + + } + + + @ValueSet( entrypoint = "WM_EVOberregister" ) + def WM_EVOberregister ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 40 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + + def where = ""; + + if ( doc.field[ 10 ] ) + { + where = " and dok_dat_feld_10 = '" + doc.field[ 10 ] + "' "; + } + + + def sqlQuery = "select distinct top (10000) dok_dat_feld_40 from firmen_spezifisch where kue_dokuart in ( 'AEVOR' ) " + where; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_40 } ); + } + + } + + + @ValueSet( entrypoint = "WM_EVRegister" ) + def WM_EVRegister ( D3Interface d3, RepositoryField reposField, User user, DocumentType docType, + int rowNo, int validate, Document doc ) + { + + if ( user.id == "d3_server" || user.id == "d3_async" ) + { + List tmpList = [doc.field[ 39 ]] + reposField.provideValuesForValueSet( tmpList ); + return 0; + } + + def where = ""; + + if ( doc.field[ 10 ] ) + { + where = " and dok_dat_feld_10 = '" + doc.field[ 10 ] + "' "; + } + + if ( doc.field[ 40 ] ) + { + where = where + " and dok_dat_feld_40 = '" + doc.field[ 40 ] + "' "; + } + + + + def sqlQuery = "select distinct top (10000) dok_dat_feld_39 from firmen_spezifisch where kue_dokuart in ( 'AEVRE' ) " + where; + + //d3.log.info( "SQLQUERY WM " + sqlQuery ); + + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + reposField.provideValuesForValueSet( resultRows.collect{ it.dok_dat_feld_39 } ); + } + + } + + + + + + + + + + + + + + + + +} \ No newline at end of file diff --git a/Kleeberg/30_hooks.groovy b/Kleeberg/30_hooks.groovy new file mode 100644 index 0000000..8f3a506 --- /dev/null +++ b/Kleeberg/30_hooks.groovy @@ -0,0 +1,3346 @@ +package com.dvelop.hooks; + + +import com.amazonaws.util.IOUtils +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.DocumentType +import com.dvelop.d3.server.User +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.D3Exception +import com.google.gson.JsonArray +import com.google.gson.JsonElement +import com.google.gson.JsonObject +import com.google.gson.JsonParser +import groovy.json.StringEscapeUtils +import org.apache.http.HttpEntity +import org.apache.http.client.methods.CloseableHttpResponse +import org.apache.http.client.methods.HttpGet +import org.apache.http.client.methods.HttpPost +import org.apache.http.entity.StringEntity +import org.apache.http.impl.client.CloseableHttpClient +import org.apache.http.impl.client.HttpClientBuilder +import org.apache.http.util.EntityUtils +import groovy.json.JsonSlurper +import java.nio.charset.StandardCharsets; + +import wslite.* +import wslite.soap.* + +// Global d.3 libraries +import com.dvelop.d3.server.core.D3Interface; +import com.dvelop.d3.server.Document; +import com.dvelop.d3.server.User; +import com.dvelop.d3.server.DocumentType; + +// Libraries to handle the diferent hook types +import com.dvelop.d3.server.Entrypoint; + + + + +public class D3Hooks +{ + + + @Entrypoint( entrypoint = "hook_insert_entry_10" ) + public int insertEntry_10( D3Interface d3, User user, DocumentType docTypeShort, Document doc ) + { + //Alle Dokumente und Akten sollen im Status Freigabe importiert werden: + doc.setStatus( "Freigabe" ); + + + //def e = getUserIdpId( d3, "dvelop", "b3be8a21-9cc1-5079-8dac-1c719ac7f80f", "https://d3one-test.kleeberg.kleeberg.de/", "lEtMJfO/jQqDvrfHTtdD5GZ0Ro8S5/UVO1NQkxGwrFCTznNl78gKtcUXXBn1mdVZh75+Nym9PjcZTZyIGrT16Nt9Lbqjpz0A3B/qCF9kDZI=&_z_A0V5ayCRn_Bn5wFTNnf3FUYT7AzFYDFJtTKz2vib1R4XhvF5pT8ZXjCzqiNkbw6I2Nrk4uR-QafuJy0XujnfyNQFfItf3" ); + def sqlQuery = ""; + def where = ""; + def resultRows = ""; + def oreg, reg, ureg, ureg2, ureg3, such_doku_art; + def where_allg = " dok_dat_feld_1 = '"+ doc.field[ 1 ] + "' "; + + + + ////////////////////////////////////// + // Prüfen, ob in einem der Benutzerfelder eine E-Mail-Adresse angegeben wurde. Ist das der Fall, so wird der entsprechende Benutzer in der Benutzer-Tabelle gesucht und mit seinem Kürzel eingetragen. START + ////////////////////////////////////// + + if ( docTypeShort.id == "AMAND" ) + { + + // Hier wird für die Eigenschaft Geschäftsführer aus der Tribus-Schnittstelle das DDF45 gefüllt. Benutzt wird in der Akte das Feld 25. Gemacht wird diese Brücke, damit sich Änderungen + // an der Akte im DATEV nicht direkt in Aktenaktualisierungsjobs im d.3 manifestieren. Das gleiche Verfahren wird für den Mandatsverantwortlichen verwendet. + + + + /////////////////////////////////////////// + // DDF 25 / Geschäftsführer + /////////////////////////////////////////// + def benutzername = "nicht ermittelbar"; + if ( doc.field[ 45 ] ) + { + if ( doc.field[ 45 ].indexOf( "@" ) > 0 ) + { + def sql_STATEMENT = "select realname + ' (' + benutzername + ')' as realbenutzername from benutzer where email = '" + doc.field[ 45 ] + "'"; + + def sql_resultRows = d3.sql.executeAndGet( (String) sql_STATEMENT ); + + if ( sql_resultRows.size() > 0 ) + { + benutzername = sql_resultRows[ 0 ].realbenutzername; + } + } + } + + xlog( d3, 4, "Mandatenakte " + doc.id + " / " + doc.field[ 1 ] + " : GF " + benutzername ); + + doc.field[ 25 ] = benutzername; + + + /////////////////////////////////////////// + // DDF 37 / Mandatsverantwortlicher + /////////////////////////////////////////// + benutzername = "nicht ermittelbar"; + if ( doc.field[ 44 ] ) + { + if ( doc.field[ 44 ].indexOf( "@" ) > 0 ) + { + def sql_STATEMENT = "select realname + ' (' + benutzername + ')' as realbenutzername from benutzer where email = '" + doc.field[ 44 ] + "'"; + + def sql_resultRows = d3.sql.executeAndGet( (String) sql_STATEMENT ); + + if ( sql_resultRows.size() > 0 ) + { + benutzername = sql_resultRows[ 0 ].realbenutzername; + } + } + } + + xlog( d3, 4, "Mandatenakte " + doc.id + " / " + doc.field[ 1 ] + " : GF " + benutzername ); + + doc.field[ 37 ] = benutzername; + + + + + } + + ////////////////////////////////////// + // Prüfen, ob in einem der Benutzerfelder eine E-Mail-Adresse angegeben wurde. Ist das der Fall, so wird der entsprechende Benutzer in der Benutzer-Tabelle gesucht und mit seinem Kürzel eingetragen. ENDE + ////////////////////////////////////// + + + ///////////////////////////////////////// + // Allgemeines START + ///////////////////////////////////////// + + + switch ( docTypeShort.id ) + { + // Das folgende betrifft alle Mandantenakte-Dokument- und Aktenarten: + case "DBETR": + case "DDAUE": + case "DABSC": + case "DBERA": + case "DSTEU": + case "DFIBU": + case "DLOHN": + case "DDEBD": + case "DLSTD": + case "DKRED": + + case "AMAND": + + case "ABPSA": + case "ABESA": + case "AFBSA": + case "AJASA": + case "ALOSA": + case "ASTSA": + + case "AJAOB": + case "ALBRE": + case "AJAAB": + case "ABERO": + case "ABERA": + case "ASTOR": + case "ASTRA": + case "ABEPA": + case "ABEOR": + case "AFIOR": + case "AFIRA": + case "ALBOR": + case "ALBSO": + case "AAURR": + case "AKROR": + case "DUMMY": + case "AOREG": + case "AREGS": + case "AUREG": + case "AURG2": + case "AURG3": + case "AAURU": + case "AAUR2": + case "ABEUR": + case "ABEU2": + case "ABPUR": + case "ABPU2": + case "AFIUR": + case "AFIU2": + case "AJAUR": + case "AJAU2": + case "ALJUR": + case "ALOUR": + case "ALJR2": + case "ALBU2": + case "ASTU2": + case "ASTUR": + case "ADAUR": + case "ABERB": + case "ABETR": + case "AFIBA": + case "AJAAA": + case "AKRED": + case "ALOJA": + case "ALBSA": + case "ASTEU": + + + + + + + ////////////////////////////////////// + // Falls "gesperrt" nicht gesetzt ist, setze das Feld auf "Nein" START + ////////////////////////////////////// + + if ( ! doc.field[ 43 ] ) + { + doc.field[ 43 ] = "Nein"; + } + + ////////////////////////////////////// + // Falls "gesperrt" nicht gesetzt ist, setze das Feld auf "Nein" ENDE + ////////////////////////////////////// + + + + + ////////////////////////////////////// + // Falls "Benachrichtigung Postempfänger" nicht gesetzt ist, setze das Feld auf "Nein" START + ////////////////////////////////////// + + if ( ! doc.field[ 38 ] ) + { + doc.field[ 38 ] = "Nein"; + } + + ////////////////////////////////////// + // Falls "Benachrichtigung Postempfänger" nicht gesetzt ist, setze das Feld auf "Nein" ENDE + ////////////////////////////////////// + + + ////////////////////////////////////// + // Falls Aktennummer gesetzt, fülle die Mandantinformationen: START + ////////////////////////////////////// + + if ( doc.field[ 10 ] ) + { + doc.field[ 1 ] = doc.field[ 10 ].substring( 0, 5 ); + + sqlQuery = "select dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + doc.field[ 1 ] + "'"; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + + if ( resultRows.size() > 0 ) + { + doc.field[ 2 ] = resultRows[ 0 ].dok_dat_feld_2; + doc.field[ 13 ] = resultRows[ 0 ].dok_dat_feld_13; + } + } + + + + + ////////////////////////////////////// + // Falls Aktennummer gesetzt, fülle die Mandantinformationen: ENDE + ////////////////////////////////////// + + + + // Prüfe, ob Aktennummer angegeben wurde und gleichzeitig die Mandantennummer weggelassen wurde. Dann kann die Mandantennummer aus der Aktennummer extrahiert werden. + if ( ( ! doc.field[ 1 ] ) && ( doc.field[ 10 ] ) ) + { + doc.field[ 1 ] = doc.field[ 10 ].substring( 0, 5 ); + } + + + + + // Falls Unterregister leer: leere auch Unterregister 2 + if ( ! doc.field[ 23 ] ) + { + doc.field[ 17 ] = ""; + } + + // Falls Unterregister 2 leer: leere auch Unterregister 3 + if ( ! doc.field[ 17 ] ) + { + doc.field[ 32 ] = ""; + } + + + ///////////////////////////////////////// + // Setzen der Register START + ///////////////////////////////////////// + + + def wm_typ = ""; + def do_it = 0; // Steuerung des Füllens des Registers auf Basis des Dokumenttyps + def gj_do_it = 0; // Steuerung des Füllens des Feldes Geschäftsjahr + + + switch ( docTypeShort.id ) + { + case "DDAUE": + wm_typ = "Dauerakte"; + + // Sonderfall Unterregister: Unterregister gefüllt? Falls ja: Oberregister + Register können direkt gefüllt werden. + // + if ( doc.field[ 23 ] != null ) + { + sqlQuery = "select dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + wm_typ + "' and dok_dat_feld_4 = '" + doc.field[ 23 ] + "'"; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + doc.field[ 3 ] = resultRows[ 0 ].dok_dat_feld_2; + doc.field[ 4 ] = resultRows[ 0 ].dok_dat_feld_3; + } + else + { + do_it = 1; + } + } + else + { + do_it = 1; + } + break; + case "DABSC": + do_it = 1; + wm_typ = "Jahresabschlussakte"; + gj_do_it = 1; + break; + case "DBERA": + case "ABERA": + do_it = 1; + wm_typ = "Beratungsakte"; + gj_do_it = 1; + break; + case "DSTEU": + do_it = 1; + wm_typ = "Steuerakte"; + gj_do_it = 2; + break; + case "DBETR": + do_it = 1; + wm_typ = "Betriebspruefungsakte"; + gj_do_it = 2; + break; + case "DLOHN": + do_it = 1; + wm_typ = "Lohnbuchhaltungjahresakte"; + gj_do_it = 2; + break; + case "DLSTD": + do_it = 1; + wm_typ = "Lohnbuchhaltungsstammdatenakte"; + // In den Lohnbuchhaltungsstammdaten gibt es kein Geschäftsjahr, daher bleibt gj_do_it unverändert + break; + case "DDEBD": + do_it = 1; + wm_typ = "Ausgangsrechnungsregister"; + gj_do_it = 1; + break; + case "DKRED": + do_it = 1; + wm_typ = "Kreditorenaktenregister"; + gj_do_it = 1; + break; + + default: + break; + } + + + + // Register gefüllt? + if ( ( doc.field[ 4 ] != null ) && ( do_it == 1 ) ) + { + // Füllen des Registers auf Basis des Dokumenttyps + sqlQuery = "select dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + wm_typ + "' and dok_dat_feld_3 = '" + doc.field[ 4 ] + "'"; + + resultRows = d3.sql.executeAndGet( sqlQuery ); + + if ( resultRows.size() > 0 ) + { + doc.field[ 3 ] = resultRows[ 0 ].dok_dat_feld_2; + } + + } + + + + switch ( gj_do_it ) + { + case 1: + // Wird verwendet für Dokumentarten in der Mandantenakte, die sowohl das Geschäftsjahr als auch das Belegdatum enthalten. + // Falls ein Belegdatum angegeben wurde, aber kein Geschäftsjahr, setze Geschäftsjahr auf das Jahr des Belegdatums + if ( ( doc.field[ 50 ] ) && ( ! doc.field[ 5 ] ) ) + { + def jahr = doc.field[ 50 ].getYear().toInteger() + 1900; + doc.field[ 5 ] = jahr.toString(); + } + break; + case 2: + // Wird verwendet für Dokumentarten in der Mandantenakte, die das Geschäftsjahr, nicht aber das Belegdatum enthalten. + // Falls Geschäftsjahr leer ist: setze aktuelles Jahr + if ( ! doc.field[ 5 ] ) + { + def jahr = new Date().getYear().toInteger() + 1900; + doc.field[ 5 ] = jahr.toString(); + } + break; + } + + + ///////////////////////////////////////// + // Setzen der Register ENDE + ///////////////////////////////////////// + + } + + + + ///////////////////////////////////////// + // Allgemeines ENDE + ///////////////////////////////////////// + + + + + + + ///////////////////////////////////////// + // Kreditor Stammdatenergänzung START + ///////////////////////////////////////// + + + if ( docTypeShort.id == "DKRED" ) + { + if ( doc.field[ 10 ] ) + { + doc.field[ 19 ] = doc.field[ 10 ].substring( 0, 5 ); + } + + if ( ( doc.field[ 19 ] ) && ( ! doc.field[ 20 ] ) ) + { + sqlQuery = "select dok_dat_feld_20 from firmen_spezifisch where kue_dokuart = 'AKRED' and dok_dat_feld_19 = '" + doc.field[ 19 ] + "' "; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + doc.field[ 20 ] = resultRows[ 0 ].dok_dat_feld_20; + } + } + + if ( ( doc.field[ 20 ] ) && ( ! doc.field[ 19 ] ) ) + { + sqlQuery = "select dok_dat_feld_19 from firmen_spezifisch where kue_dokuart = 'AKRED' and dok_dat_feld_20 = '" + doc.field[ 20 ] + "' "; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + doc.field[ 19 ] = resultRows[ 0 ].dok_dat_feld_19; + } + } + + } + + + ///////////////////////////////////////// + // Kreditor Stammdatenergänzung ENDE + ///////////////////////////////////////// + + + ///////////////////////////////////////// + // Eigenverwaltungsakte Stammdatenergänzung START + ///////////////////////////////////////// + + switch ( docTypeShort.id ) + { + case "DEVDO": + case "AEVAK": + case "AEVOR": + case "AEVRE": + + if ( ( doc.field[ 10 ] ) && ( ! doc.field[ 21 ] ) ) + { + sqlQuery = "select dok_dat_feld_21 from firmen_spezifisch where kue_dokuart = 'AEVAK' and dok_dat_feld_10 = '" + doc.field[ 10 ] + "' "; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + doc.field[ 21 ] = resultRows[ 0 ].dok_dat_feld_21; + } + } + + if ( ( doc.field[ 21 ] ) && ( ! doc.field[ 10 ] ) ) + { + sqlQuery = "select dok_dat_feld_10 from firmen_spezifisch where kue_dokuart = 'AEVAK' and dok_dat_feld_21 = '" + doc.field[ 21 ] + "' "; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + doc.field[ 10 ] = resultRows[ 0 ].dok_dat_feld_10; + } + } + } + + ///////////////////////////////////////// + // Eigenverwaltungsakte Stammdatenergänzung ENDE + ///////////////////////////////////////// + + + ////////////////////////////////////////////////////// + // Verarbeitung Mandantenakte START + ////////////////////////////////////////////////////// + + + switch ( docTypeShort.id ) + { + case "AMAND": + + + break; + case "DBETR": + + ////////////////////////////////////// + // Bei Betriebsprüfungsdokumenten müssen die Prüfungsart und der Prüfungszeitraum von der Akte geholt und an das Dokument ergänzt werden START + ////////////////////////////////////// + + if ( doc.field[ 10 ] ) + { + sqlQuery = "select dok_dat_feld_12, dok_dat_feld_14 from firmen_spezifisch where kue_dokuart = 'ABETR' and dok_dat_feld_10 = '" + doc.field[ 10 ] + "' "; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + if ( resultRows[ 0 ].dok_dat_feld_12 ) + { + doc.field[ 12 ] = resultRows[ 0 ].dok_dat_feld_12; + } + + if ( resultRows[ 0 ].dok_dat_feld_14 ) + { + doc.field[ 14 ] = resultRows[ 0 ].dok_dat_feld_14; + } + } + } + + + + + + + ////////////////////////////////////// + // Bei Betriebsprüfungsdokumenten müssen die Prüfungsart und der Prüfungszeitraum von der Akte geholt und an das Dokument ergänzt werden ENDE + ////////////////////////////////////// + + case "DDAUE": + case "DEVDO": + case "DABSC": + case "DBERA": + case "DSTEU": + case "DFIBU": + case "DLOHN": + case "DDEBD": + case "DLSTD": + case "DKRED": + + + + + + + + // Falls Betreff leer: setze Betreff auf den Dateinamen + if ( ! doc.field[ 6 ] ) + { + doc.field[ 6 ] = doc.getFilename(); + d3.log.info( "setze Betreff auf " + doc.getFilename() ); + } + + // Falls Dokumentdatum leer: Setze Dokumentdatum auf Tagesdatum + if ( ! doc.field[ 50 ] ) + { + doc.field[ 50 ] = new Date(); + } + + + // Für Eigenverwaltungsdokumente ist hier Schluss. + if ( docTypeShort.id == "DEVDO" ) + { + break; + } + + ////////////////////////////////////// + // Im Zuge der Archivierung muss geprüft werden, ob es unterhalb der angegebenen Register noch weitere Unterregister gibt. Ist das der Fall, müssen diese vom Anwender ausgewählt werden; + // d.h. eine Archivierung wird dann abgelehnt. START + ////////////////////////////////////// + + // Diese Logik ist aufgrund einer E-Mail von Hrn. Meyer vom 11. Februar 2022 13:58 Uhr an JFEL, ISTRE und CBUE deaktiviert. + + + if ( false ) // Logik ist deaktiviert + { + // Festlegen, in welcher Aktenart gesucht werden soll: + + switch( docTypeShort.id ) + { + case "DDAUE": // Dauerakte + oreg = "AOREG"; + reg = "AREGS"; + ureg = "AUREG"; + ureg2 = "AURG2"; + ureg3 = "AURG3"; + break; + case "DABSC": // Jahresabschlussakte + oreg = "AJAOB"; + reg = "AJAAB"; + ureg = "AJAUR"; + ureg2 = "AJAU2"; + break; + case "DBERA": // Beratungsakte + oreg = "ABERO"; + reg = "ABERA"; + ureg = "ABEUR"; + ureg2 = "ABEU2"; + break; + case "DSTEU": // Steuerakte + oreg = "ASTOR"; + reg = "ASTRA"; + ureg = "ASTUR"; + ureg2 = "ASTU2"; + break; + case "DBETR": // Betriebspruefungsakte + oreg = "ABEOR"; + reg = "ABEPA"; + ureg = "ABPUR"; + ureg2 = "ABPU2"; + break; + case "DFIBU": // Finanzbuchhaltungsakte + oreg = "AFIOR"; + reg = "AFIRA"; + ureg = "AFIUR"; + ureg2 = "AFIU2"; + break; + case "DLOHN": // Lohnbuchhaltungjahresakte + oreg = "ALBOR"; + reg = "ALBRE"; + ureg = "ALJUR"; + ureg2 = "ALJR2"; + break; + case "DDEBD": // Ausgangsrechnungsakte + oreg = "AAURR"; + reg = "AAURA"; + ureg = "AAURU"; + ureg2 = "AAUR2"; + break; + case "DLSTD": // Lohnbuchhaltungsstammdatenakte + oreg = "ALBSO"; + reg = "ALORE"; + ureg = "ALOUR"; + ureg2 = "ALBU2"; + break; + case "DKRED": // Kreditorenakte + oreg = "AKROR"; + reg = "AKRER"; + ureg = "AKREU"; + ureg2 = "AKRU2"; + break; + } + + + + + def such_feld; + def such_ok = false; + def add_i_t; + + where = ""; + + if ( doc.field[ 3 ] ) // Oberregister + { + where = " and dok_dat_feld_3 = '" + doc.field[ 3 ] + "' "; + such_doku_art = reg; + such_feld = 4; + add_i_t = "Es gibt Register unterhalb von '" + doc.field[ 3 ] + "'. Bitte verwenden Sie diese."; + such_ok = true; + + if ( doc.field[ 4 ] ) // Register + { + where = where + " and dok_dat_feld_4 = '" + doc.field[ 4 ] + "' "; + such_doku_art = ureg; + such_feld = 23; + add_i_t = "Es gibt Register unterhalb von '" + doc.field[ 4 ] + "'. Bitte verwenden Sie diese."; + such_ok = true; + + if ( doc.field[ 23 ] ) // Unterregister + { + where = where + " and dok_dat_feld_23 = '" + doc.field[ 23 ] + "' "; + such_doku_art = ureg2; + such_feld = 17; + add_i_t = "Es gibt Register unterhalb von '" + doc.field[ 23 ] + "'. Bitte verwenden Sie diese."; + such_ok = true; + + if ( doc.field[ 17 ] ) // 2. Unterregister + { + where = where + " and dok_dat_feld_17 = '" + doc.field[ 17 ] + "' "; + such_doku_art = ureg3; + such_feld = 32; + add_i_t = "Es gibt Register unterhalb von '" + doc.field[ 17 ] + "'. Bitte verwenden Sie diese."; + such_ok = true; + + if ( doc.field[ 32 ] ) // 3. Unterregister + { + // Wenn das 3. Unterregister gefüllt ist, braucht die Prüfung nicht stattzufinden, weil der Anwender eh keine weiteren Register angeben kann. + // Da ist dann nur noch die Prüfung fällig, ob das Register auch existiert, die findet aber an anderer Stelle statt. + + such_ok = false; + } + } + } + } + } + + + + + if ( such_ok ) + { + + where = where_allg + where + " and dok_dat_feld_" + such_feld + " is not null "; + + sqlQuery = "select count(*) anzahl from firmen_spezifisch where kue_dokuart = '" + such_doku_art + "' and " + where; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + if ( resultRows[ 0 ].anzahl > 0 ) + { + // Es wurde eine Kombination gefunden => es gibt vorhandene, aber nicht vom Anwender ausgewählte Unterregister. + d3.hook.setProperty( "additional_info_text", add_i_t ); + return -502; + } + } + } + + + } + + ////////////////////////////////////// + // Im Zuge der Archivierung muss geprüft werden, ob es unterhalb der angegebenen Register noch weitere Unterregister gibt. Ist das der Fall, müssen diese vom Anwender ausgewählt werden; + // d.h. eine Archivierung wird dann abgelehnt. ENDE + ////////////////////////////////////// + + + + + + + + case "AJAOB": + case "ALBRE": + case "AJAAB": + case "ABERO": + case "ABERA": + case "ASTOR": + case "ASTRA": + case "ABEPA": + case "ABEOR": + case "AFIOR": + case "AFIRA": + case "ALBOR": + case "ALBSO": + case "AAURR": + case "AKROR": + case "DUMMY": + case "AOREG": + case "AREGS": + + ////////////////////////////////////////////////////// + // Grundstücksangabe muss ein Pflichtfeld sein, wenn eine 04.01 Grundstück-Akte ausgewählt wurde START + ////////////////////////////////////////////////////// + + + // Diese Logik ist aufgrund einer E-Mail von Hrn. Meyer vom 11. Februar 2022 13:58 Uhr an JFEL, ISTRE und CBUE deaktiviert. + + if ( false ) // Logik ist deaktiviert + { + // Gilt für Daueraktendokumente, Daueraktenunterregister und 2. Daueraktenunterregister + // Bedingungen: + // o DDF 4 (Register) wurde angegeben + // o DDF 30 ist leer => ein Grundstück wurde nicht angegeben + // o DDF 23 ist gefüllt => es wurde ein Unterregister angegeben + // o Dokumentart ist DDAUE oder AUREG oder AURG2 + if ( ( doc.field[ 4 ] ) && ( ! doc.field[ 30 ] ) && ( doc.field[ 23 ] ) && ( ( docTypeShort.id == "DDAUE" ) || ( docTypeShort.id == "AUREG" ) || ( docTypeShort.id == "AURG2" ) ) ) + { + def grundstueck_korrekter_ordner = false; + def grundstueck_ordner = doc.field[ 23 ].substring( 0, 8 ); + + switch ( grundstueck_ordner ) + { + case "04.01.01": + case "04.01.02": + case "04.01.03": + case "04.01.04": + grundstueck_korrekter_ordner = true; + } + + + if ( ( grundstueck_korrekter_ordner ) && ( doc.field[ 4 ].substring( 0, 13 ) == "04.01 Grundst" ) ) + { + return -505; + } + } + } + + ////////////////////////////////////////////////////// + // Grundstücksangabe muss ein Pflichtfeld sein, wenn eine 04.01 Grundstück-Akte ausgewählt wurde ENDE + ////////////////////////////////////////////////////// + + + + + + + + case "AUREG": + case "AURG2": + case "AURG3": + + case "AAURU": + case "AAUR2": + + case "ABEUR": + case "ABEU2": + + case "ABPUR": + case "ABPU2": + + case "AFIUR": + case "AFIU2": + + case "AJAUR": + case "AJAU2": + + case "ALJUR": + case "ALOUR": + case "ALJR2": + case "ALBU2": + + case "ASTU2": + case "ASTUR": + + + + //////////////////////////////////////////////////////// + // Es muss geprüft werden, ob eine gewählte Registerkombination valide ist, d.h. für einen Mandanten so existiert. Dabei muss unterschieden werden, ob die Akte gerade angelegt werden soll oder ein + // Dokument innerhalb der Akte abgelegt werden soll. START + //////////////////////////////////////////////////////// + + def doktyp_art = docTypeShort.id.substring( 0, 1 ); + + + + + + + if ( doktyp_art == "D" ) + { + // Es soll ein Dokument abgelegt werden + // Hier müssen alle angegebenen Register existieren + + + // Festlegen, in welcher Aktenart gesucht werden soll: + //def oreg, reg, ureg, ureg2, ureg3; + + where_allg = " dok_dat_feld_10 = '" + doc.field[ 10 ] + "' "; + + switch( docTypeShort.id ) + { + case "DDAUE": + oreg = "AOREG"; + reg = "AREGS"; + ureg = "AUREG"; + ureg2 = "AURG2"; + ureg3 = "AURG3"; + break; + case "DABSC": + oreg = "AJAOB"; + reg = "AJAAB"; + ureg = "AJAUR"; + ureg2 = "AJAU2"; + break; + case "DBERA": + oreg = "ABERO"; + reg = "ABERA"; + ureg = "ABEUR"; + ureg2 = "ABEU2"; + break; + case "DSTEU": + oreg = "ASTOR"; + reg = "ASTRA"; + ureg = "ASTUR"; + ureg2 = "ASTU2"; + break; + case "DBETR": + oreg = "ABEOR"; + reg = "ABEPA"; + ureg = "ABPUR"; + ureg2 = "ABPU2"; + break; + case "DFIBU": + oreg = "AFIOR"; + reg = "AFIRA"; + ureg = "AFIUR"; + ureg2 = "AFIU2"; + break; + case "DLOHN": + oreg = "ALBOR"; + reg = "ALBRE"; + ureg = "ALJUR"; + ureg2 = "ALJR2"; + break; + case "DDEBD": + oreg = "AAURR"; + reg = "AAURA"; + ureg = "AAURU"; + ureg2 = "AAUR2"; + break; + case "DLSTD": + oreg = "ALBSO"; + reg = "ALORE"; + ureg = "ALOUR"; + ureg2 = "ALBU2"; + break; + case "DKRED": + oreg = "AKROR"; + reg = "AKRER"; + ureg = "AKREU"; + ureg2 = "AKRU2"; + where_allg = " dok_dat_feld_19 = '"+ doc.field[ 19 ] + "' "; + break; + } + + + + where = ""; + + if ( doc.field[ 3 ] ) // Oberregister + { + where = " and " + where_allg + " and dok_dat_feld_3 = '" + doc.field[ 3 ] + "' "; + such_doku_art = oreg; + + if ( doc.field[ 4 ] ) // Register + { + where = where + " and dok_dat_feld_4 = '" + doc.field[ 4 ] + "' "; + such_doku_art = reg; + + if ( doc.field[ 23 ] ) // Unterregister + { + where = where + " and dok_dat_feld_23 = '" + doc.field[ 23 ] + "' "; + such_doku_art = ureg; + + if ( doc.field[ 17 ] ) // 2. Unterregister + { + where = where + " and dok_dat_feld_17 = '" + doc.field[ 17 ] + "' "; + such_doku_art = ureg2; + + if ( doc.field[ 32 ] ) // 3. Unterregister + { + where = where + " and dok_dat_feld_32 = '" + doc.field[ 32 ] + "' "; + such_doku_art = ureg3; + } + } + } + } + } + + + + sqlQuery = "select count(*) anzahl from firmen_spezifisch where kue_dokuart = '" + such_doku_art + "' " + where; + + //d3.log.error( sqlQuery ); + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + if ( resultRows[ 0 ].anzahl == 0 ) + { + d3.log.error( "Es konnte keine passende Registerkombination gefunden werden. Der Import wird abgelehnt." ) + + return -501; + } + } + + + } + else + { + + + + // Es soll eine Akte angelegt werden + // Hier müssen alle bis auf das unterste Register existieren + + // Welche Register müssen vorhanden sein? (_mds => müssen da sein). + // Oberregister werden nicht geprüft, weil sie immer da sein müssen. + + def reg_mds, ureg_mds, ureg2_mds; + + def pruefe_register = true; + + switch ( docTypeShort.id ) + { + case "AOREG": // Mandantenakte + Ebene Oberregister: müssen nicht geprüft werden + case "AJAOB": + case "ABERO": + case "ASTOR": + case "ABEOR": + case "AFIOR": + case "ALBOR": + case "AAURR": + case "ALBSO": + case "AKROR": + case "AMAND": + pruefe_register = false; + break; + case "AURG3": // Ebene Unterregister 3 (nur Dauerakte) + reg_mds = true; + ureg_mds = true; + ureg2_mds = true; + such_doku_art = "AURG2"; + break; + case "AURG2": // Ebene Unterregister 2 + reg_mds = true; + ureg_mds = true; + ureg2_mds = false; + such_doku_art = "AUREG"; + break; + case "AJAU2": + reg_mds = true; + ureg_mds = true; + ureg2_mds = false; + such_doku_art = "AJAUR"; + break; + case "ABEU2": + reg_mds = true; + ureg_mds = true; + ureg2_mds = false; + such_doku_art = "ABEUR"; + break; + case "ASTU2": + reg_mds = true; + ureg_mds = true; + ureg2_mds = false; + such_doku_art = "ASTUR"; + break; + case "ABPU2": + reg_mds = true; + ureg_mds = true; + ureg2_mds = false; + such_doku_art = "ABPUR"; + break; + case "AFIU2": + reg_mds = true; + ureg_mds = true; + ureg2_mds = false; + such_doku_art = "AFIUR"; + break; + case "ALJR2": + reg_mds = true; + ureg_mds = true; + ureg2_mds = false; + such_doku_art = "ALJUR"; + break; + case "AAUR2": + reg_mds = true; + ureg_mds = true; + ureg2_mds = false; + such_doku_art = "AAURU"; + break; + case "ALBU2": + reg_mds = true; + ureg_mds = true; + ureg2_mds = false; + such_doku_art = "ALOUR"; + break; + case "AKRU2": + reg_mds = true; + ureg_mds = true; + ureg2_mds = false; + such_doku_art = "AKREU"; + break; + case "AUREG": // Ebene Unterregister + reg_mds = true; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "AREGS"; + break; + case "AJAUR": + reg_mds = true; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "AJAAB"; + break; + case "ABEUR": + reg_mds = true; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "ABERA"; + break; + case "ASTUR": + reg_mds = true; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "ASTRA"; + break; + case "ABPUR": + reg_mds = true; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "ABEPA"; + break; + case "AFIUR": + reg_mds = true; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "AFIRA"; + break; + case "ALJUR": + reg_mds = true; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "ALBRE"; + break; + case "AAURU": + reg_mds = true; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "AAURA"; + break; + case "ALOUR": + reg_mds = true; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "ALORE"; + break; + case "AKREU": + reg_mds = true; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "AKRER"; + break; + case "AREGS": // Ebene Register + reg_mds = false; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "AOREG"; + break; + case "AJAAB": + reg_mds = false; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "AJAOB"; + break; + case "ABERA": + reg_mds = false; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "ABERO"; + break; + case "ASTRA": + reg_mds = false; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "ASTOR"; + break; + case "ABEPA": + reg_mds = false; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "ABEOR"; + break; + case "AFIRA": + reg_mds = false; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "AFIOR"; + break; + case "ALBRE": + reg_mds = false; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "ALBOR"; + break; + case "AAURA": + reg_mds = false; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "AAURR"; + break; + case "ALORE": + reg_mds = false; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "ALBSO"; + break; + case "AKRER": + reg_mds = false; + ureg_mds = false; + ureg2_mds = false; + such_doku_art = "AKROR"; + break; + + } + + + + + + where = where_allg + " and dok_dat_feld_3 = '" + doc.field[ 3 ] + "' "; + + if ( reg_mds ) + { + where = where + " and dok_dat_feld_4 = '" + doc.field[ 4 ] + "' "; + } + + if ( ureg_mds ) + { + where = where + " and dok_dat_feld_23 = '" + doc.field[ 23 ] + "' "; + } + + if ( ureg2_mds ) + { + where = where + " and dok_dat_feld_17 = '" + doc.field[ 17 ] + "' "; + } + + if ( pruefe_register ) + { + + sqlQuery = "select count(*) anzahl from firmen_spezifisch where kue_dokuart = '" + such_doku_art + "' and " + where; + + //d3.log.error( "sqlQuery: 1 " + sqlQuery ); + + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + if ( resultRows[ 0 ].anzahl == 0 ) + { + d3.log.error( "Es konnte keine passende Registerkombination gefunden werden. Der Import wird abgelehnt." ) + + return -501; + } + } + } + } + + + //////////////////////////////////////////////////////// + // Es muss geprüft werden, ob eine gewählte Registerkombination valide ist, d.h. für einen Mandanten so existiert. Dabei muss unterschieden werden, ob die Akte gerade angelegt werden soll oder ein + // Dokument innerhalb der Akte abgelegt werden soll. ENDE + //////////////////////////////////////////////////////// + + + + + + + case "ADAUR": + case "ABERB": + case "ABETR": + case "AFIBA": + case "AJAAA": + case "AKRED": + case "ALOJA": + case "ALBSA": + case "ASTEU": + + // Prüfe, ob Aktennummer und Mandant zusammenpassen, ggf. Meldung + if ( ( doc.field[ 1 ] ) && ( doc.field[ 10 ] ) ) + { + // Aktennummer und Mandantnummer sind beide gefüllt + + if ( doc.field[ 1 ] != doc.field[ 10 ].substring( 0, 5 ) ) + { + // Aktennummer passt nicht zur Mandantennummer + d3.log.error( "Die angegebene Aktennummer passt nicht zur angegeben Mandantennummer. Der Import wird abgelehnt." ) + return -503; + } + + } + + + + + + + + /////////////////////// + // Aktenkürzel-Buchstabenanteil groß schreiben: + if ( doc.field[ 10 ] ) + { + doc.field[ 10 ] = doc.field[ 10 ].toUpperCase(); + } + + + /////////////////////// + // Prüfe, ob Aktennummer zu ausgewählter Dokumentart passt START + /////////////////////// + + if ( doc.field[ 10 ] ) + { + def aktenkuerzel = ""; + def lzahlen = "0123456789"; + + for ( int m = 0; m <= doc.field[ 10 ].length() -1 ; m++ ) + { + if ( lzahlen.indexOf( doc.field[ 10 ].substring( m, m + 1 ) ) == -1 ) + { + aktenkuerzel = aktenkuerzel + doc.field[ 10 ].substring( m, m + 1 ); + } + } + + d3.log.info( "Dokument-/Aktenart " + docTypeShort.id + " / gefundenes Aktenkuerzel " + aktenkuerzel ); + + // RC -507: Es wurde versucht, ein Dokument mit einer Aktennummer in eine für diese Aktennummer nicht passende Dokumentart zu importieren. + + + + + + switch( docTypeShort.id ) + { + case "DDAUE": // Dauerakte + case "AOREG": + case "AREGS": + case "AUREG": + case "AURG2": + case "AURG3": + if ( aktenkuerzel != "DA" ) + { + return -507; + } + break; + case "DABSC": // Jahresabschlussakte + case "AJAOB": + case "AJAAB": + case "AJAUR": + case "AJAU2": + if ( aktenkuerzel != "JA" ) + { + return -507; + } + break; + case "DBERA": // Beratungsakte + case "ABERO": + case "ABERA": + case "ABEUR": + case "ABEU2": + if ( aktenkuerzel != "BE" ) + { + return -507; + } + break; + case "DSTEU": // Steuerakte + case "ASTOR": + case "ASTRA": + case "ASTUR": + case "ASTU2": + if ( aktenkuerzel != "ST" ) + { + return -507; + } + break; + case "DBETR": // Betriebspruefungsakte + case "ABEOR": + case "ABEPA": + case "ABPUR": + case "ABPU2": + if ( aktenkuerzel != "BP" ) + { + return -507; + } + break; + case "DFIBU": // Finanzbuchhaltungsakte + case "AFIOR": + case "AFIRA": + case "AFIUR": + case "AFIU2": + if ( aktenkuerzel != "FI" ) + { + return -507; + } + break; + case "DLOHN": // Lohnbuchhaltungjahresakte + case "ALBOR": + case "ALBRE": + case "ALJUR": + case "ALJR2": + if ( aktenkuerzel != "LO" ) + { + return -507; + } + break; + case "DDEBD": // Ausgangsrechnungsakte + case "AAURR": + case "AAURA": + case "AAURU": + case "AAUR2": + if ( aktenkuerzel != "RE" ) + { + return -507; + } + break; + case "DLSTD": // Lohnbuchhaltungsstammdatenakte + case "ALBSO": + case "ALORE": + case "ALOUR": + case "ALBU2": + if ( aktenkuerzel != "LS" ) + { + return -507; + } + break; + case "DKRED": // Kreditorenakte + case "AKROR": + case "AKRER": + case "AKREU": + case "AKRU2": + if ( aktenkuerzel != "KA" ) + { + return -507; + } + break; + } + + + } + + /////////////////////// + // Prüfe, ob Aktennummer zu ausgewählter Dokumentart passt ENDE + /////////////////////// + + + + + + /////////////////////// + // Mandantinformationen ergänzen START + /////////////////////// + + if ( doc.field[ 1 ] ) + { + def sql = groovy.sql.Sql.newInstance( "jdbc:sqlserver://kp-sql01\\D3;databaseName=D3P_Datev", 'd3_master', 'Xbn8"Ep4', 'com.microsoft.sqlserver.jdbc.SQLServerDriver' ); + + def row = sql.firstRow( "select clientname, number from DatevClients where number = '" + doc.field[ 1 ] + "'" ); + + if ( row ) + { + doc.field[ 1 ] = (String) row.number; + doc.field[ 2 ] = row.clientname; + //doc.field[ 13 ] = (String) row.number; + } + + sql.close(); + } + + + /////////////////////// + // Mandantinformationen ergänzen ENDE + /////////////////////// + + + + + + /////////////////////// + // Setzen des Feldes Briefkopf, falls noch nicht gefüllt START + /////////////////////// + + if ( ! doc.field[ 42 ] ) + { + doc.field[ 42 ] = "Kleeberg"; + } + + /////////////////////// + // Setzen des Feldes Briefkopf, falls noch nicht gefüllt ENDE + /////////////////////// + + + + + + + + ////////////////////////////////////////////////////// + // automatisches Vergeben einer Aktennummer, ggf. Füllen des Aktennamens START + ////////////////////////////////////////////////////// + + + + + + + def akten_kuerzel; + def akten_name; + def akten_verfahren; + + switch ( docTypeShort.id ) + { + case "ADAUR": // Dauerakte + case "DDAUE": // Daueraktendokumente + case "AOREG": // Oberregister + case "AREGS": // Register + case "AUREG": // Unterregister + case "AURG2": // 2. Unterregister + akten_kuerzel = "DA"; + akten_name = "Dauerakte"; + akten_verfahren = 1; + break; + + case "AAURE": // Ausgangsrechnungsakte + case "DDEBD": // Debitorendokumente + case "AAURR": // Ausgangsrechnungsregister + akten_kuerzel = "RE"; + akten_name = "Ausgangsrechnungsakte"; + akten_verfahren = 1; + break; + case "ABERA": + case "DBERA": + case "ABERO": + case "ABERB": + akten_kuerzel = "BE"; + akten_name = "Beratungsakte"; + akten_verfahren = 1; + break; + case "DSTEU": + case "ASTEU": + case "ASTRA": + case "ASTOR": + akten_kuerzel = "ST"; + akten_name = "Steuerakte"; + akten_verfahren = 2; + break; + case "DBETR": + case "ABETR": + case "ABEPA": + case "ABEOR": + akten_kuerzel = "BP"; + akten_name = "Betriebspruefungsakte"; + akten_verfahren = 1; + break; + case "DFIBU": + case "AFIBA": + case "AFIOR": + case "AFIRA": + akten_kuerzel = "FI"; + akten_name = "Finanzbuchhaltungsakte"; + akten_verfahren = 1; + break; + case "DLOHN": + case "ALOJA": + case "ALBOR": + case "ALBRE": + akten_kuerzel = "LO"; + akten_name = "Lohnbuchhaltungs-Jahresakte"; + akten_verfahren = 2; + break; + case "DLSTD": + case "ALBSO": + case "ALBSA": + akten_kuerzel = "ST"; + akten_name = "Steuerakte"; + akten_verfahren = 1; + break; + case "DKRED": + case "AKRED": + case "ALBSA": + akten_kuerzel = "KR"; + akten_name = "Kreditorakte"; + akten_verfahren = 1; + break; + } + + if ( doc.field[ 10 ] ) + { + // Aktennummer ist gefüllt + if ( ! doc.field[ 21 ] ) + { + // Es wurde kein Aktenname angegeben + sqlQuery = "select dok_dat_feld_21 from firmen_spezifisch where dok_dat_feld_10 = '" + doc.field[10] + "' and kue_dokuart in ( 'ADAUR', 'ABERB', 'ABETR', 'AFIBA', 'AJAAA', 'AKRED', 'ALOJA', 'ALBSA', 'ASTEU' )"; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + doc.field[ 21 ] = resultRows[ 0 ].dok_dat_feld_21; + } + else + { + doc.field[ 21 ] = akten_name; + } + } + } + else + { + + // Aktennummer ist leer + if ( akten_verfahren == 1 ) + { + // Aktennummer: + + // Mit diesem Verfahren wird bei leerer Aktennummer nach Akten dieses Typs gesucht. Die höchste gefundene Aktensuffixnummer wird dann um 1 inkrementiert und als + // Grundlage für die neue Aktennummer verwendet. + + if ( docTypeShort.id.substring( 0,1 ) == "A" ) + { + // Bei Aktenanlage wird die Aktennummer generiert, falls nicht angegeben. + + sqlQuery = "select distinct dok_dat_feld_10 from firmen_spezifisch where kue_dokuart in ( \ + 'ADAUR', 'AAURE', 'ABERB', 'ABETR', 'AFIBA', 'AJAAA', 'AKRED', 'ALOJA', 'ALBSA', 'ASTEU', 'DBERA', 'DDAUE', 'DBETR', 'DDEBD', 'DFIBU', 'DABSC', 'DKRED', 'DLOHN', 'DLSTD', 'DSTEU' \ + ) and dok_dat_feld_10 like '" + doc.field[ 1 ] + akten_kuerzel + "%' order by dok_dat_feld_10 desc" + + resultRows = d3.sql.executeAndGet( sqlQuery ); + + if ( resultRows.size() > 0 ) + { + //12345DA000100 + def akten_suffix = resultRows[ 0 ].dok_dat_feld_10; + + + // Transformieren des DB-Treffers in die Ziel-Aktennummer + akten_suffix = akten_suffix.substring( 7, 11 ); // Ausschneiden der Aktensuffixnummer + int akt_suff = akten_suffix as Integer; // Typkonvertierung nach Integer + akt_suff = akt_suff + 1; // +1 weil neue Akte/Dokument + akten_suffix = akt_suff.toString(); // Typkonvertierung zurück nach String + akten_suffix = akten_suffix.padLeft( 4, "0" ); // Hinzufügen von Nullen bis zu einer Gesamtlänge von 4 Stellen + + + // Setzen der neuen Aktennummer + des Aktennamens + doc.field[ 10 ] = doc.field[ 1 ] + akten_kuerzel + akten_suffix + "00"; + doc.field[ 21 ] = akten_name; + + + + + } + else + { + // Es wurde keine passende Akte/Dokument gefunden: + doc.field[ 10 ] = doc.field[ 1 ] + akten_kuerzel + "0000" + "00"; + doc.field[ 21 ] = akten_name; + } + } + else + { + // Bei Dokumentarten wird eine Aktennummer gesucht und bei Erfolg als erste vorgeschlagen + sqlQuery = "select distinct dok_dat_feld_10, dok_dat_feld_21 from firmen_spezifisch where kue_dokuart in ( \ + 'ADAUR', 'AAURE', 'ABERB', 'ABETR', 'AFIBA', 'AJAAA', 'AKRED', 'ALOJA', 'ALBSA', 'ASTEU', 'DBERA', 'DDAUE', 'DBETR', 'DDEBD', 'DFIBU', 'DABSC', 'DKRED', 'DLOHN', 'DLSTD', 'DSTEU' \ + ) and dok_dat_feld_10 like '" + doc.field[ 1 ] + akten_kuerzel + "%' order by dok_dat_feld_10 desc" + + resultRows = d3.sql.executeAndGet( sqlQuery ); + + if ( resultRows.size() > 0 ) + { + doc.field[ 10 ] = resultRows[ 0 ].dok_dat_feld_10; + doc.field[ 21 ] = resultRows[ 0 ].dok_dat_feld_21; + } + else + { + // Der Benutzer muss zuerst die entsprechende Akte erstellen (siehe msglib.usr) + return -506; + } + } + } + else + { + // Aktuell haben die Unterstrukturen der Kreditorakte keine Aktennummer, daher werden diese hier nochmal explizit ausgenommen + if ( "AKROR".equals( docTypeShort.id ) || "AKRER".equals( docTypeShort.id ) || "AKREU".equals( docTypeShort.id ) ) + { + d3.log.info( "keine Aktennummer bei Kreditorstrukturakten vorhanden" ); + } + else + { + // Jahresakten haben ein etwas anderes Schema + def jahr = new Date().getYear().toInteger() + 1900; + def akten_suffix = jahr.toString(); + // Setzen der neuen Aktennummer + des Aktennamens + doc.field[ 10 ] = doc.field[ 1 ] + akten_kuerzel + akten_suffix + "00"; + doc.field[ 21 ] = akten_name; + + } + } + } + + + + ////////////////////////////////////////////////////// + // automatisches Vergeben einer Aktennummer, ggf. Füllen des Aktennamens ENDE + ////////////////////////////////////////////////////// + } + + + + + + + ////////////////////////////////////////////////////// + // Verarbeitung Mandantenakte ENDE + ////////////////////////////////////////////////////// + + + + + + + + + return 0; + } + + + @Entrypoint( entrypoint = "hook_insert_exit_20" ) + public int insertExit_20( D3Interface d3, Document doc, String fileDestination, int importOk, User user, DocumentType docTypeShort ) + { + + ////////////////////////////////////////////////////// + // Erstellen des Aktenbaums bei Anlage einer Mandantenakte START + ////////////////////////////////////////////////////// + + + + if ( docTypeShort.id == "AMAND" ) + { + + //xlog( d3, 4, "1 *********************************************************" ); + //xlog( d3, 4, "insertExit_20: " + docTypeShort.id + " / " + doc.id + " START " ); + //xlog( d3, 4, "Mandatenakte " + doc.id + " / " + doc.field[ 1 ] + " / " + doc.field[ 2 ] ); + //xlog( d3, 4, "1 *********************************************************" ); + + ////////////////////////////////////////// + // erste Ebene unterhalb der neuen Mandantenakte anlegen + // (Dauerakte, Ausgangsrechnungsakte sowie alle Sammelakten) + def akten_ebene_1 = [ "ADAUR", "ALOSA", "ASTSA", "AJASA", "AFBSA", "ABPSA", "ABESA", "AAURE" ]; + + + // Daueraktennummer, -name + def daueraktennr = doc.field[ 1 ] + "DA000000"; + def daueraktenname = "Dauerakte"; + + def ausgangsrechaktennr = doc.field[ 1 ] + "RE000100"; + def ausgangsrechaktenname = "Ausgangsrechnungsakte"; + + def splitted_str_array_69 = []; + + + akten_ebene_1.each + { + + + + + xlog( d3, 4, "-----------------------" ); + xlog( d3, 4, "Mandatenakte " + doc.id + " / " + doc.field[ 1 ] + " : erstelle Akte vom Typ " + it ); + //d3.log.info( " erstelle Akte vom Typ " + it ); + def zieltabelle; + def resultRows; + def akte_aus_migration = false; + def check_db = false; + + + Document newDoc = d3.archive.newDocument(); + + newDoc.type = it; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + // Mandantnummer, -name, -gruppennummer, physischer Aufbewahrungsort, Geschäftsführer + newDoc.field[ 1 ] = doc.field[ 1 ]; + newDoc.field[ 2 ] = doc.field[ 2 ]; + newDoc.field[ 13 ] = doc.field[ 13 ]; + newDoc.field[ 22 ] = "Digital"; + newDoc.field[ 25 ] = doc.field[ 25 ]; // Geschäftsführer + newDoc.field[ 37 ] = doc.field[ 37 ]; // Mandatsverantwortlicher + newDoc.field[ 42 ] = "Kleeberg"; + + switch ( it ) + { + case "ADAUR": + zieltabelle = "mig_dauerakte"; + + xlog( d3, 4, "Mandatenakte " + doc.id + " / " + doc.field[ 1 ] + " : erstelle Dauerakte mit GF " + doc.field[ 25 ] ); + xlog( d3, 4, "Mandatenakte " + doc.id + " / " + doc.field[ 1 ] + " : erstelle Dauerakte mit MV " + doc.field[ 37 ] ); + + newDoc.field[ 10 ] = daueraktennr; + newDoc.field[ 21 ] = daueraktenname; + newDoc.field[ 60 ][ 1 ] = doc.field[ 25 ]; + if ( doc.field[ 25 ] != doc.field[ 37 ] ) + { + newDoc.field[ 60 ][ 2 ] = doc.field[ 37 ]; + } + + check_db = true; + + break; + + case "AAURE": + zieltabelle = "mig_ausgangsrechnungsakte"; + + xlog( d3, 4, "Mandatenakte " + doc.id + " / " + doc.field[ 1 ] + " : erstelle AR-Akte mit GF " + doc.field[ 25 ] ); + xlog( d3, 4, "Mandatenakte " + doc.id + " / " + doc.field[ 1 ] + " : erstelle AR-Akte mit MV " + doc.field[ 37 ] ); + + newDoc.field[ 10 ] = ausgangsrechaktennr; + newDoc.field[ 21 ] = ausgangsrechaktenname; + newDoc.field[ 60 ][ 1 ] = doc.field[ 25 ]; + if ( doc.field[ 25 ] != doc.field[ 37 ] ) + { + newDoc.field[ 60 ][ 2 ] = doc.field[ 37 ]; + } + + check_db = true; + + break; + + default: + check_db = false; + break; + } + + + + if ( check_db ) + { + def sqlQuery = "select id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69 from " + zieltabelle + " where ddf1 = '" + doc.field[ 1 ] + "' and fehler is null and doku_id is null"; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + akte_aus_migration = true; + + xlog( d3, 4, "Mandatenakte " + doc.id + ": Datensatz fuer Dauerakte gefunden." ); + // Falls ein Wert in der Tabelle gefunden wurde, überschreibt der in der Tabelle gefundene Wert den "geerbten" von der Mandantenakte: + // Daueraktennummer: + if ( resultRows[ 0 ].ddf10 ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + ": Setze DDF10: " + resultRows[ 0 ].ddf10 ); + newDoc.field[ 10 ] = resultRows[ 0 ].ddf10; + } + + // Daueraktenname: + if ( resultRows[ 0 ].ddf21 ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + ": Setze DDF21: " + resultRows[ 0 ].ddf21 ); + newDoc.field[ 21 ] = resultRows[ 0 ].ddf21; + } + + // Physischer Aufbewahrungsort: + if ( resultRows[ 0 ].ddf22 ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + ": Setze DDF22: " + resultRows[ 0 ].ddf22 ); + newDoc.field[ 22 ] = resultRows[ 0 ].ddf22; + } + + // Geschäftsführer: + if ( resultRows[ 0 ].ddf25 ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + ": Setze DDF25: " + resultRows[ 0 ].ddf25 ); + newDoc.field[ 25 ] = resultRows[ 0 ].ddf25; + newDoc.field[ 60 ][ 1 ] = doc.field[ 25 ]; + } + + // Mandatsverantwortlicher: + if ( resultRows[ 0 ].ddf37 ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + ": Setze DDF37: " + resultRows[ 0 ].ddf37 ); + newDoc.field[ 37 ] = resultRows[ 0 ].ddf37; + newDoc.field[ 60 ][ 2 ] = doc.field[ 37 ]; + } + + // Briefkopf: + if ( resultRows[ 0 ].ddf42 ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + ": Setze DDF42: " + resultRows[ 0 ].ddf42 ); + newDoc.field[ 42 ] = resultRows[ 0 ].ddf42; + } + + // Unique-ID: + if ( resultRows[ 0 ].ddf48 ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + ": Setze DDF48: " + resultRows[ 0 ].ddf48 ); + newDoc.field[ 48 ] = resultRows[ 0 ].ddf48; + } + + // Postempfänger: + if ( resultRows[ 0 ].ddf60 ) + { + newDoc.field[ 60 ][ 1 ] = ""; + newDoc.field[ 60 ][ 2 ] = ""; + + def splitted_str_array = resultRows[ 0 ].ddf60.split( ';' ); + for ( int i = 0; i < splitted_str_array.size(); i++ ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + ": Setze DDF60 / " + i + ": " + splitted_str_array[ i ] ); + newDoc.field[ 60 ][ i + 1 ] = splitted_str_array[ i ]; + } + } + + // Berechtigter: + if ( resultRows[ 0 ].ddf69 ) + { + splitted_str_array_69 = resultRows[ 0 ].ddf69.split( ';' ); + for ( int i = 0; i < splitted_str_array_69.length; i++ ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + ": Setze DDF69 / " + i + ": " + splitted_str_array_69[ i ] ); + newDoc.field[ 69 ][ i + 1 ] = splitted_str_array_69[ i ]; + } + } + } + else + { + xlog( d3, 3, "Mandatenakte " + doc.id + ": Es wurde kein DB-Treffer gefunden (Tabelle " + zieltabelle + ", Aktenart " + it + ")." ); + } + } + + + // Prüfen, ob die zu erstellende Akte existiert: + + def sqlQuery_pruef = "select doku_id from firmen_spezifisch where kue_dokuart = '" + newDoc.type + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "'"; + + def resultRows2 = d3.sql.executeAndGet( (String) sqlQuery_pruef ); + + if ( resultRows2.size() == 0 ) + { + + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, "Dokument konnte nicht erzeugt werden: " + e.message ); + + if ( akte_aus_migration ) + { + def meldung_db; + if ( e.message.length() > 250 ) + { + meldung_db = e.message.substring( 0, 249 ); + } + else + { + meldung_db = e.message; + } + def sqlQuery = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + resultRows[ 0 ].id; + d3.sql.execute( sqlQuery ); + } + return -175; + } + + if ( akte_aus_migration ) + { + //xlog( d3, 2, "Angekommen?" ); + + xlog( d3, 4, "Mandatenakte " + doc.id + ": Setze Doku-ID " + newDoc.id + " fuer Element-ID " + resultRows[ 0 ].id + " in der Tabelle " + zieltabelle + "." ); + def sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + resultRows[ 0 ].id; + d3.sql.execute( sqlQuery ); + } + + xlog( d3, 4, "Mandatenakte " + doc.id + ": erzeugte Doku-Id: " + newDoc.id + " / " + newDoc.type ); + + } + else + { + xlog( d3, 3, "Mandatenakte " + doc.id + ": Akte vom Typ " + newDoc.type + " existiert bereits: " + resultRows[ 0 ].doku_id ); + } + + } + + + ////////////////////////////////////////// + // Ebene unterhalb der Dauerakte / Ausgangsrechnungsakte anlegen + // Dokumentart: Daueraktenoberregister / Ausgangsrechnungsberregister, darin alle in den Stammdaten angelegten Oberregister + + def sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_24 from firmen_spezifisch where kue_dokuart = 'AVMNT' and ( dok_dat_feld_1 = 'Dauerakte' or dok_dat_feld_1 = 'Ausgangsrechnungsakte' )"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + d3.log.info( " erstelle Oberregister-Akte: " + it.dok_dat_feld_24 + " / " + it.dok_dat_feld_2 ); + + Document newDoc = d3.archive.newDocument(); + + if ( it.dok_dat_feld_24 == "RE" ) + { + newDoc.type = "AAURR"; + newDoc.field[ 10 ] = ausgangsrechaktennr; // Daueraktennummer + newDoc.field[ 21 ] = ausgangsrechaktenname; // Daueraktenname + } + else + { + newDoc.type = "AOREG"; + newDoc.field[ 10 ] = daueraktennr; // Daueraktennummer + newDoc.field[ 21 ] = daueraktenname; // Daueraktenname + } + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = doc.field[ 1 ]; // Mandantnummer + newDoc.field[ 2 ] = doc.field[ 2 ]; // Mandantname + newDoc.field[ 13 ] = doc.field[ 13 ]; // Mandantgruppennummer + newDoc.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDoc.field[ 25 ] = doc.field[ 25 ]; // Geschäftsführer + newDoc.field[ 37 ] = doc.field[ 37 ]; // Mandatsverantwortlicher + + if ( splitted_str_array_69.size() > 0 ) + { + for ( int i = 0; i < splitted_str_array_69.size(); i++ ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + " / OR " + newDoc.field[ 3 ] + ":Setze DDF69 / " + i + ": " + splitted_str_array_69[ i ] ); + newDoc.field[ 69 ][ i + 1 ] = splitted_str_array_69[ i ]; + } + } + + //def ergebnis = d3.archive.importDocument( newDoc ); + // Prüfen, ob die zu erstellende Akte existiert: + + def sqlQuery_pruef = "select doku_id from firmen_spezifisch where kue_dokuart = '" + newDoc.type + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + newDoc.field[ 3 ] + "'"; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery_pruef ); + + if ( resultRows.size() == 0 ) + { + + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, "Dokument konnte nicht erzeugt werden: " + e.message ); + + return -175; + } + + xlog( d3, 4, "Mandatenakte " + doc.id + ": Akte vom Typ " + newDoc.type + " / Register [" + newDoc.field[ 3 ] + "]: erzeugte Doku-Id: " + newDoc.id ); + + } + else + { + xlog( d3, 3, "Mandatenakte " + doc.id + ": Akte vom Typ " + newDoc.type + " / Oberregister [" + newDoc.field[ 3 ] + "] existiert bereits: " + resultRows[ 0 ].doku_id ); + } + } + } + + + + ////////////////////////////////////////// + // 2. Ebene unterhalb der Dauerakte anlegen + // Dokumentart: Daueraktenregister, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = 'Dauerakte' and dok_dat_feld_3 != ''"; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + d3.log.info( " erstelle Daueraktenregister-Akte: " + it.dok_dat_feld_2 + " / " + it.dok_dat_feld_3 ); + + Document newDoc = d3.archive.newDocument(); + + newDoc.type = "AREGS"; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = doc.field[ 1 ]; // Mandantnummer + newDoc.field[ 2 ] = doc.field[ 2 ]; // Mandantname + newDoc.field[ 13 ] = doc.field[ 13 ]; // Mandantgruppennummer + newDoc.field[ 10 ] = daueraktennr; // Daueraktennummer + newDoc.field[ 21 ] = daueraktenname; // Daueraktenname + newDoc.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDoc.field[ 4 ] = it.dok_dat_feld_3; // Register + newDoc.field[ 25 ] = doc.field[ 25 ]; // Geschäftsführer + newDoc.field[ 37 ] = doc.field[ 37 ]; // Mandatsverantwortlicher + + if ( splitted_str_array_69.size() > 0 ) + { + for ( int i = 0; i < splitted_str_array_69.size(); i++ ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + " / OR " + newDoc.field[ 4 ] + ":Setze DDF69 / " + i + ": " + splitted_str_array_69[ i ] ); + newDoc.field[ 69 ][ i + 1 ] = splitted_str_array_69[ i ]; + } + } + + //def ergebnis = d3.archive.importDocument( newDoc ); + // Prüfen, ob die zu erstellende Akte existiert: + + def sqlQuery_pruef = "select doku_id from firmen_spezifisch where kue_dokuart = '" + newDoc.type + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + newDoc.field[ 3 ] + "' and dok_dat_feld_4 = '" + newDoc.field[ 4 ] + "'"; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery_pruef ); + + if ( resultRows.size() == 0 ) + { + + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, "Dokument konnte nicht erzeugt werden: " + e.message ); + + return -175; + } + + xlog( d3, 4, "Mandatenakte " + doc.id + ": Akte vom Typ " + newDoc.type + " / Register [" + newDoc.field[ 3 ] + "][" + newDoc.field[ 4 ] + "]: erzeugte Doku-Id: " + newDoc.id ); + + } + else + { + xlog( d3, 3, "Mandatenakte " + doc.id + ": Akte vom Typ " + newDoc.type + " / Register [" + newDoc.field[ 3 ] + "][" + newDoc.field[ 4 ] + "] existiert bereits: " + resultRows[ 0 ].doku_id ); + } + + } + } + + + ////////////////////////////////////////// + // 3. Ebene unterhalb der Dauerakte anlegen + // Dokumentart: Daueraktenunterregister, darin alle in den Stammdaten angelegten Unterregister + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3, dok_dat_feld_4 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = 'Dauerakte' and dok_dat_feld_3 != '' and dok_dat_feld_4 != ''"; + + resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + d3.log.info( " erstelle Daueraktenregister-Akte: " + it.dok_dat_feld_2 + " / " + it.dok_dat_feld_2 + " / " + it.dok_dat_feld_4 ); + + Document newDoc = d3.archive.newDocument(); + + newDoc.type = "AUREG"; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = doc.field[ 1 ]; // Mandantnummer + newDoc.field[ 2 ] = doc.field[ 2 ]; // Mandantname + newDoc.field[ 13 ] = doc.field[ 13 ]; // Mandantgruppennummer + newDoc.field[ 10 ] = daueraktennr; // Daueraktennummer + newDoc.field[ 21 ] = daueraktenname; // Daueraktenname + newDoc.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDoc.field[ 4 ] = it.dok_dat_feld_3; // Register + newDoc.field[ 23 ] = it.dok_dat_feld_4; // Unterregister + newDoc.field[ 25 ] = doc.field[ 25 ]; // Geschäftsführer + newDoc.field[ 37 ] = doc.field[ 37 ]; // Mandatsverantwortlicher + + if ( splitted_str_array_69.size() > 0 ) + { + for ( int i = 0; i < splitted_str_array_69.size(); i++ ) + { + //xlog( d3, 4, "Mandatenakte " + doc.id + " / UR " + newDoc.field[ 23 ] + ":Setze DDF69 / " + i + ": " + splitted_str_array_69[ i ] ); + newDoc.field[ 69 ][ i + 1 ] = splitted_str_array_69[ i ]; + } + } + + def ergebnis = d3.archive.importDocument( newDoc ); + + } + } + + + + } + + + + ////////////////////////////////////////////////////// + // Erstellen des Aktenbaums bei Anlage einer Mandantenakte ENDE + ////////////////////////////////////////////////////// + + + + ////////////////////////////////////// + // Wenn ein Dokument in der Mandantenakte abgelegt wird (d.h. in die bekannten Dokumentarten importiert wird), sollen die "Postempfänger", d.h. die Personen, die im entsprechenden Eigenschaftsfeld der zugehörigen + // Akte (Dauerakte, Beratungsakte, ...) hinterlegt sind, eine Benachrichtigung in ihren Postkorb (Kachel "Aufgaben") bekommen. START + ////////////////////////////////////// + + + if ( true ) + { + switch ( docTypeShort.id ) + { + case "DDAUE": + case "DABSC": + case "DBERA": + case "DSTEU": + case "DBETR": + case "DFIBU": + case "DLOHN": + case "DDEBD": + case "DLSTD": + case "DKRED": + + // Die Benachrichtigung soll nur erfolgen, wenn im Feld "Benachrichtigung Postempfänger" (DDF 38) der Wert "Ja" steht: + if ( doc.field[ 38 ] == "Ja" ) + { + // Welche Akte gehört zum aktuellen Dokument? + // Die Akte wird herausgefunden, indem mit der Aktennummer gesucht wird + + def sqlQuery = "select doku_id from firmen_spezifisch where dok_dat_feld_10 = '" + doc.field[ 10 ] + "' and kue_dokuart in ( 'ADAUR', 'AAURE', 'ABERB', 'ABETR', 'AFIBA', 'AJAAA', 'ALOJA', 'ALBSA', 'ASTEU' )"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + d3.log.info( "instert_exit_20: Ermittlung doku_id für Aktennummer: "+ doc.field[ 10 ]); //JFEL: 09.12.22 Erweiterung Loging aufgrund von nicht erstellten Tasks + + if ( resultRows.size() > 0 ) + { + def doku_id = resultRows[0][ "doku_id" ]; + + //d3.log.error( "gefundene Akten-ID " + doku_id ); + + def akte = d3.archive.getDocument( doku_id ); + + def username; + + ArrayList empfaenger = new ArrayList<>(); + empfaenger = []; + + def server_kuerzel = d3.config.value( "d3fc_server_id" ); + def repo_id, baseUri, authUsr; + + + switch ( server_kuerzel ) + { + case "T": + repo_id = "b3be8a21-9cc1-5079-8dac-1c719ac7f80f"; + baseUri = "https://d3one-test.kleeberg.kleeberg.de/"; + authUsr = "t4HPtO8zLfxYVu0LylFG9dVvxc6b5sBV+P1YMt6GtKx7IxoKPQO0UWsh8ch6+MPGiCfUIn4MVwhvj6SSAiKDe83vl0MbtbG4xB/Igl6ilLg=&_z_A0V5ayCQyduqJQXU6c1T8QPL7tAJUPapw4J4uxsq_6e6a8timZXZmTwaqCcqcIoecor7zzqzpY0tCUhlW1L9b3Hsxgtdw"; + break; + case "P": + repo_id = "7b813cf7-9909-54ba-a333-f62d302fdfdc"; + baseUri = "https://d3one.kleeberg.kleeberg.de/"; + authUsr = "XEnvA6iv1JlaMuWBut1oiG1sGb88zZVtlgclIzrfPnD9haZ6s+NzZEMIUPc5W4tMQarJ0N4BI1WLlCWeHvrfp8JXbflWNZMDq12iXux2lxM=&_z_A0V5ayCQKwVv9K-Z0eIw5kCzeLaJAoOxpj1fw6px159gyZQadH2d8uhawpnegUH6CDD0pisvF_lyf3Ks9qINLrPd_K263"; + break; + } + + //JFEL 06.05.2022: Anpassung zum Test der Performance + for ( int i = 1 ; i <= Integer.valueOf( d3.config.value( "CUR_60ER_FIELD_NR" ) ); i++ ) + //for ( int i = 1 ; i < 10; i++ ) + { + // Iterieren über die gefundenen Benutzer: + + if ( akte.field[ 60 ][ i ] ) + { + + username = getUserIdpId( d3, akte.field[ 60 ][ i ].substring( akte.field[ 60 ][ i ].indexOf ( "(" ) + 1, akte.field[ 60 ][ i ].indexOf( ")" ) ), repo_id, baseUri, authUsr ); + + empfaenger.push( username ); + + //d3.log.error( "insert_exit_20: Task für Username "+ username); //JFEL: 09.12.22 Erweiterung Loging aufgrund von nicht erstellten Tasks + + def e = createTask( d3, user, docTypeShort, doc, "ND " + doc.field[ 10 ] + " / " + doc.field[ 6 ], "Zur Kenntnisnahme: Es wurde ein neues Dokument in die Akte " + doc.field[ 10 ] + " des Mandanten " + doc.field[ 2 ] + "/" + doc.field[ 1 ] + " importiert.", empfaenger, baseUri, authUsr, repo_id ); + + empfaenger.remove( username ); + } + else + { + //break; + } + } + } + } + } + + + } + + + ////////////////////////////////////// + // Wenn ein Dokument in der Mandantenakte abgelegt wird (d.h. in die bekannten Dokumentarten importiert wird), sollen die "Postempfänger", d.h. die Personen, die im entsprechenden Eigenschaftsfeld der zugehörigen + // Akte (Dauerakte, Beratungsakte, ...) hinterlegt sind, eine Benachrichtigung in ihren Postkorb (Kachel "Aufgaben") bekommen. ENDE + ////////////////////////////////////// + + + + + + ////////////////////////////////////// + // Wenn ein Dokument in der Mandantenakte abgelegt wird (d.h. in die bekannten Dokumentarten importiert wird), soll geprüft werden, ob das Dokument noch an weitere Stellen verknüpft werden soll - diese + // Verknüpfungen sollen dann erzeugt werden START + ////////////////////////////////////// + + + if ( true ) + { + switch ( docTypeShort.id ) + { + case "DDAUE": + case "DABSC": + case "DBERA": + case "DSTEU": + case "DBETR": + case "DFIBU": + case "DLOHN": + case "DDEBD": + case "DLSTD": + case "DKRED": + if ( doc.field[ 48 ] ) + { + // Unique-ID ist gesetzt => prüfe, ob das Dokument verknüpft werden soll: + + //def STATEMENT = "select doku_id_target_fol from mig_link_docs where Unique_ID_DOC = '" + doc.field[ 48 ] + "'"; + + def STATEMENT = "select firmen_spezifisch.doku_id doku_id_target_fol from mig_link_docs_2 left join firmen_spezifisch on firmen_spezifisch.dok_dat_feld_10 = mig_link_docs_2.ddf10 \ + where mig_link_docs_2.Unique_ID_Doc = '" + doc.field[ 48 ] + "' \ + and mig_link_docs_2.ddf10 = firmen_spezifisch.dok_dat_feld_10 \ + and mig_link_docs_2.DDF3 = firmen_spezifisch.dok_dat_feld_3 \ + and (mig_link_docs_2.DDF4 = firmen_spezifisch.dok_dat_feld_4 or (mig_link_docs_2.DDF4 is null and firmen_spezifisch.dok_dat_feld_4 is null)) \ + and (mig_link_docs_2.DDF23 = firmen_spezifisch.dok_dat_feld_23 or (mig_link_docs_2.DDF23 is null and firmen_spezifisch.dok_dat_feld_23 is null)) \ + and (mig_link_docs_2.DDF17 = firmen_spezifisch.dok_dat_feld_17 or (mig_link_docs_2.DDF17 is null and firmen_spezifisch.dok_dat_feld_17 is null)) \ + and (mig_link_docs_2.DDF32 = firmen_spezifisch.dok_dat_feld_32 or (mig_link_docs_2.DDF32 is null and firmen_spezifisch.dok_dat_feld_32 is null)) \ + and ( firmen_spezifisch.doku_id != '" + doc.id + "') \ + and (firmen_spezifisch.kue_dokuart like 'A%') \ + order by doku_id"; + + //d3.log.error( STATEMENT ); + + def verknuepf_akten = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( verknuepf_akten.size() > 0 ) + { + verknuepf_akten.each + { + //def ergebnis = d3.call.link_documents( it.doku_id_target_fol, doc.id, "Master", false, false ); + + def insSTATEMENT = "insert into mig_multi_link_work (doku_id_father, doku_id_child) values ('" + it.doku_id_target_fol + "', '" + doc.id + "');"; + + def insERG = d3.sql.execute( (String) insSTATEMENT ); + + //xlog( d3, 2, insERG ); + + if ( insERG != 1 ) + { + xlog( d3, 2, "Es gab ein Problem beim Vorbereiten der Aktenverknuepfung zwischen [" + it.doku_id_target_fol + "] (Vater) und [" + doc.id + "] (Kind)." ); + } + + //if ( ergebnis != 0 ) + //{ + // xlog( d3, 2, "Herstellen der zusaetzlichen Aktenverknuepfung zwischen Parent-Dok-ID [" + it.doku_id_target_fol + "] und Child-Dok-ID [" + doc.id + "] ist gescheitert: RC [" + ergebnis + "]" ); + //} + } + + } + } + + } + + } + + + ////////////////////////////////////// + // Wenn ein Dokument in der Mandantenakte abgelegt wird (d.h. in die bekannten Dokumentarten importiert wird), soll geprüft werden, ob das Dokument noch an weitere Stellen verknüpft werden soll - diese + // Verknüpfungen sollen dann erzeugt werden ENDE + ////////////////////////////////////// + + + ////////////////////////////////////// + // Festhalten des Importzeitpunktes für Dokumente / Akten START + ////////////////////////////////////// + + doclog( d3, 4, "Import Dokument [" + doc.id + "] Dokumentart [" + docTypeShort.id + "] " ); + + ////////////////////////////////////// + // Festhalten des Importzeitpunktes für Dokumente / Akten ENDE + ////////////////////////////////////// + + + return 0; + } + + + @Entrypoint( entrypoint = "hook_validate_import_entry_10" ) + public int hookValidateImportEntry10( D3Interface d3, User user, DocumentType docType, Document doc, String nextcall ) + { + d3.log.info("START | hookValidateImportEntry10 "); + + d3.log.info("ENDE | hookValidateImportEntry10 "); + return 0; + } + + + @Entrypoint(entrypoint="hook_link_entry_30") + public int linkEntry30 ( D3Interface d3, Document docFather, Document docChild ) + { + //d3.log.info("START | linkEntry30 "); + // Unterhalb der angegebenen Akten sollen keine Dokumente verknüpft werden können: + + // Die Prüfung wird nur durchgeführt, wenn das Dokument noch nicht verknüpft ist - nach der ersten Verknüpfung, die zwingend in der korrekten Akte erfolgen muss, + // sind weitere Verknüpfungen wohin auch immer erlaubt. + + def ergebnis = d3.call.link_get_parents( docChild.id, "Master" ); + + //d3.log.info("linkEntry30 Anzahl Elternelemente: " + ergebnis.length ); + + if ( ( ergebnis.length == 0 ) && ( ! docChild.field[ 48 ] ) ) + { + + switch ( docChild.getType().getId() ) + { + case "DBERA": + case "DBETR": + case "DDAUE": + case "DDEBD": + case "DFIBU": + case "DABSC": + case "DLOHN": + case "DLSTD": + case "DSTEU": + + switch ( docFather.getType().getId() ) + { + case "AMAND": // Mandantenakte + case "ADAUR": // Dauerakte + case "ASTSA": // Steuer-Sammelakte + case "ALOSA": // Lohnbuchhaltungs-Sammelakte + case "AJASA": // Jahresabschluss-Sammelakte + case "AFBSA": // Finanzbuchhaltungs-Sammelakte + case "ABPSA": // Betriebsprüfungs-Sammelakte + case "ABESA": // Beratungs-Sammelakte + case "ABERB": // Beratungsakte + case "ABETR": // Betriebspruefungsakte + case "AFIBA": // Finanzbuchhaltungsakte + case "AJAAA": // Jahresabschlussakte + case "ALOJA": // Lohnbuchhaltungs-Jahresakte + case "ALBSA": // Lohnbuchhaltungsstammdatenakte + case "ASTEU": // Steuerakte + + return -1; + } + + // Prüfen, ob das Kind-Dokument im richtigen Register abgelegt wurde + // Jedes beim Kind gefüllte Register (gleich welcher Ebene) muss auch bei der Vaterakte mit dem gleichen Wert gefüllt sein + + //d3.log.info( docChild.id + " / " + docFather.id + ": Unterschied in DDF 3: " + docChild.field[ 3 ] + "/" + docFather.field[ 3 ] ); + //d3.log.info( docChild.id + " / " + docFather.id + ": Unterschied in DDF 4: " + docChild.field[ 4 ] + "/" + docFather.field[ 4 ] ); + //d3.log.info( docChild.id + " / " + docFather.id + ": Unterschied in DDF 23: " + docChild.field[ 23 ] + "/" + docFather.field[ 23 ] ); + //d3.log.info( docChild.id + " / " + docFather.id + ": Unterschied in DDF 17: " + docChild.field[ 17 ] + "/" + docFather.field[ 17 ] ); + //d3.log.info( docChild.id + " / " + docFather.id + ": Unterschied in DDF 32: " + docChild.field[ 32 ] + "/" + docFather.field[ 32 ] ); + + // Oberregister + if ( ! ( docChild.field[ 3 ] == docFather.field[ 3 ] ) ) + { + return -192; + } + + // Register + if ( ! ( docChild.field[ 4 ] == docFather.field[ 4 ] ) ) + { + return -192; + } + + // Unterregister + if ( ! ( docChild.field[ 23 ] == docFather.field[ 23 ] ) ) + { + return -192; + } + + // 2. Unterregister + if ( ! ( docChild.field[ 17 ] == docFather.field[ 17 ] ) ) + { + return -192; + } + + // 3. Unterregister + if ( ! ( docChild.field[ 32 ] == docFather.field[ 32 ] ) ) + { + return -192; + } + } + } + + + + return 0; + } + + + @Entrypoint(entrypoint="hook_upd_attrib_entry_20") + public int upd_attrib_entry_20( D3Interface d3, Document doc, User user, DocumentType docType, DocumentType docTypeNew ) + { + + + ////////////////////////////////////// + // Prüfen, ob in einem der Benutzerfelder eine E-Mail-Adresse angegeben wurde. Ist das der Fall, so wird der entsprechende Benutzer in der Benutzer-Tabelle gesucht und mit seinem Kürzel eingetragen. START + ////////////////////////////////////// + + if ( docType.id == "AMAND" ) + { + + // Hier wird für die Eigenschaft Geschäftsführer aus der Tribus-Schnittstelle das DDF45 gefüllt. Benutzt wird in der Akte das Feld 25. Gemacht wird diese Brücke, damit sich Änderungen + // an der Akte im DATEV nicht direkt in Aktenaktualisierungsjobs im d.3 manifestieren. Das gleiche Verfahren wird für den Mandatsverantwortlichen verwendet. + + + + /////////////////////////////////////////// + // DDF 25 / Geschäftsführer + /////////////////////////////////////////// + def benutzername = "nicht ermittelbar"; + if ( doc.field[ 45 ] ) + { + if ( doc.field[ 45 ].indexOf( "@" ) > 0 ) + { + def sql_STATEMENT = "select realname + ' (' + benutzername + ')' as realbenutzername from benutzer where email = '" + doc.field[ 45 ] + "'"; + + def sql_resultRows = d3.sql.executeAndGet( (String) sql_STATEMENT ); + + if ( sql_resultRows.size() > 0 ) + { + benutzername = sql_resultRows[ 0 ].realbenutzername; + } + } + } + doc.field[ 25 ] = benutzername; + + + /////////////////////////////////////////// + // DDF 37 / Mandatsverantwortlicher + /////////////////////////////////////////// + benutzername = "nicht ermittelbar"; + if ( doc.field[ 44 ] ) + { + if ( doc.field[ 44 ].indexOf( "@" ) > 0 ) + { + def sql_STATEMENT = "select realname + ' (' + benutzername + ')' as realbenutzername from benutzer where email = '" + doc.field[ 44 ] + "'"; + + def sql_resultRows = d3.sql.executeAndGet( (String) sql_STATEMENT ); + + if ( sql_resultRows.size() > 0 ) + { + benutzername = sql_resultRows[ 0 ].realbenutzername; + } + } + } + doc.field[ 37 ] = benutzername; + + + + + } + + ////////////////////////////////////// + // Prüfen, ob in einem der Benutzerfelder eine E-Mail-Adresse angegeben wurde. Ist das der Fall, so wird der entsprechende Benutzer in der Benutzer-Tabelle gesucht und mit seinem Kürzel eingetragen. ENDE + ////////////////////////////////////// + + //////////////////////////// + // Grundstücke sollen nur bei Dauerregisterakten angelegt werden können, wenn das Register "04.01 Grundstücke" ist START + //////////////////////////// + + + + if ( docType.id == "AREGS" ) + { + // Prüfen, ob die Eigenschaft Grundstücke Werte enthält + def gefunden = false; + + for ( int i = 1 ; i <= Integer.valueOf( d3.config.value( "CUR_60ER_FIELD_NR" ) ); i++ ) + { + if ( doc.field[ 68 ][ i ] ) + { + gefunden = true; + break; + } + } + + + if ( ( gefunden ) && ( doc.field[ 4 ].substring( 0, 13 ) != "04.01 Grundst" ) ) + { + d3.log.info( "Grundstücke sind nur bei Daueraktenregisterakten mit dem Register '04.01 Grundstücke' anlegbar!" ); + return -177; + } + + } + + + + //////////////////////////// + // Grundstücke sollen nur bei Dauerregisterakten angelegt werden können, wenn das Register "04.01 Grundstücke" ist ENDE + //////////////////////////// + + + //////////////////////////// + // Vererben von Berechtigungen von einer Hauptakte (Dauerakte, Beratungsakte etc.) auf untergeordnete Akten + Dokumente START + //////////////////////////// + + if ( false ) // Logik ist ausgeschaltet + { + + switch ( docTypeNew.id ) + { + // Ausgangsrechnungsakte: + case "AAURE": + case "AAURR": + case "AAURA": + case "AAURU": + case "AAUR2": + // Beratungsakte: + case "ABERB": + case "ABERO": + case "ABERA": + case "ABEUR": + case "ABEU2": + // Betriebsprüfungsakte: + case "ABETR": + case "ABEOR": + case "ABEPA": + case "ABPUR": + case "ABPU2": + // Dauerakte: + case "ADAUR": + case "AOREG": + case "AREGS": + case "AUREG": + case "AURG2": + // Finanzbuchhaltungsakte: + case "AFIBA": + case "AFIOR": + case "AFIRA": + case "AFIUR": + case "AFIU2": + // Jahresabschlussakte: + case "AJAAA": + case "AJAOB": + case "AJAAB": + case "AJAUR": + case "AJAU2": + // Lohnbuchhaltungjahresakte: + case "ALOJA": + case "ALBOR": + case "ALBRE": + case "ALJUR": + case "ALJR2": + // Lohnbuchhaltungsstammdate: + case "ALBSA": + case "ALBSO": + case "ALORE": + case "ALOUR": + case "ALBU2": + // Steuerakte: + case "ASTEU": + case "ASTOR": + case "ASTRA": + case "ASTUR": + case "ASTU2": + + // Kreditorakte: + case "AKRED": + case "AKROR": + case "AKRER": + case "AKREU": + case "AKRU2": + + // Eigenverwaltungsakte: + case "AEVAK": + case "AEVOR": + case "AEVRE": + + + // Untergeordnete Akten/Dokumente ermitteln + def unterdoks = d3.call.link_get_children( doc.id, "Master" ); + + unterdoks.each + { + + def currentDoc = d3.archive.getDocument( it ); + + if ( currentDoc.field[ 10 ] == doc.field[ 10 ] ) + { + //xlog( d3, 1, "Dokument: " + it ); + + // Ãœbernahme des Briefkopfs, falls beim Kind leer. Sollte eigentlich nicht notwendig sein, da Pflichtfeld. Im Testsystem gibt es aber auch + // Akten, bei denen nachträglich als Pflichtfeld definierte Felder leer sind - das Feld Briefkopf ist so ein Fall. + if ( ! currentDoc.field[ 42 ] ) + { + //currentDoc.field[ 42 ] = doc.field[ 42 ]; + } + + if ( ! currentDoc.field[ 42 ] ) + { + //currentDoc.field[ 42 ] = "Kleeberg"; + } + + //JFEL 06.05.2022: Test der Performance mit weniger Werten beim Schleifendurchlauf + //for ( int i = 1 ; i <= Integer.valueOf( d3.config.value( "CUR_60ER_FIELD_NR" ) ); i++ ) + //xlog( d3, 3, "(hook_upd_attrib_entry_20) Berechtigungen aktualisieren bei Dokument " + it + " Beginn" ); + //for ( int i = 1 ; i < 10 ; i++ ) + for ( int i = 1 ; i <= Integer.valueOf( d3.config.value( "CUR_60ER_FIELD_NR" ) ); i++ ) + { + if ( ! doc.field[ 69 ][ i ] ) + { + //break; + } + + currentDoc.field[ 69 ][ i ] = doc.field[ 69 ][ i ]; + } + //xlog( d3, 3, "(hook_upd_attrib_entry_20) Berechtigungen aktualisieren bei Dokument " + it + " Ende" ); + + // Diese Felder müssen ebenfalls gesetzt werden, damit die Aktualisierung der untergeordneten Dokumente/Akten in jedem Fall funktioniert: + //currentDoc.field[ 2 ] = doc.field[ 2 ]; // Mandantname + //currentDoc.field[ 13 ] = doc.field[ 13 ]; // Mandantgruppennummer + //currentDoc.field[ 21 ] = doc.field[ 21 ]; // Aktenname + + currentDoc.updateAttributes( "Master" ); + + } + } + + break; + } + + + + } + + //////////////////////////// + // Vererben von Berechtigungen auf Hauptakte (Dauerakte, Beratungsakte etc.) auf untergeordnete Akten + Dokumente START + //////////////////////////// + + + + + return 0; + } + + + @Entrypoint( entrypoint = "hook_link_exit_10" ) + public int hook_link_exit_10 ( D3Interface d3, Document docFather, Document docChild, Integer errorCode ) + { + //xlog( d3, 3, "(hook_link_exit_10) Berechtigungen aktualisieren bei Dokument " + docChild.id ); + + //////////////////////////// + // Vererben von Berechtigungen von einer Hauptakte (Dauerakte, Beratungsakte etc.) auf untergeordnete Akten + Dokumente START + //////////////////////////// + + // Ist der Vater eine Akte aus der Mandantenakte/Kreditorenakte, dann vererbe der Vater die Berechtigungen (DDF69) an das Kind (neue Dokument/Akte). + + if ( false ) + { + switch ( docFather.getType().id ) + { + // Ausgangsrechnungsakte: + case "AAURE": + case "AAURR": + case "AAURA": + case "AAURU": + case "AAUR2": + // Beratungsakte: + case "ABERB": + case "ABERO": + case "ABERA": + case "ABEUR": + case "ABEU2": + // Betriebsprüfungsakte: + case "ABETR": + case "ABEOR": + case "ABEPA": + case "ABPUR": + case "ABPU2": + // Dauerakte: + case "ADAUR": + case "AOREG": + case "AREGS": + case "AUREG": + case "AURG2": + // Finanzbuchhaltungsakte: + case "AFIBA": + case "AFIOR": + case "AFIRA": + case "AFIUR": + case "AFIU2": + // Jahresabschlussakte: + case "AJAAA": + case "AJAOB": + case "AJAAB": + case "AJAUR": + case "AJAU2": + // Lohnbuchhaltungjahresakte: + case "ALOJA": + case "ALBOR": + case "ALBRE": + case "ALJUR": + case "ALJR2": + // Lohnbuchhaltungsstammdate: + case "ALBSA": + case "ALBSO": + case "ALORE": + case "ALOUR": + case "ALBU2": + // Steuerakte: + case "ASTEU": + case "ASTOR": + case "ASTRA": + case "ASTUR": + case "ASTU2": + // Kreditorenakte: + case "AKRED": + case "AKROR": + case "AKRER": + case "AKREU": + case "AKRU2": + // Eigenverwaltungsakte: + case "AEVAK": + case "AEVOR": + case "AEVRE": + + if ( docChild.field[ 10 ] == docFather.field[ 10 ] ) + { + //JFEL 06.05.2022 Anpassung zum Test der Performance + //for ( int i = 1 ; i < 10 ; i++ ) + for ( int i = 1 ; i <= Integer.valueOf( d3.config.value( "CUR_60ER_FIELD_NR" ) ); i++ ) + { + if ( ! docFather.field[ 69 ][ i ] ) + { + break; + } + + docChild.field[ 69 ][ i ] = docFather.field[ 69 ][ i ]; + } + + docChild.updateAttributes( "Master" ); + + } + + } + + + } + + //////////////////////////// + // Vererben von Berechtigungen auf Hauptakte (Dauerakte, Beratungsakte etc.) auf untergeordnete Akten + Dokumente ENDE + //////////////////////////// + + + //////////////////////////// + // Feststellen, wo das Dokument überall verknüpft ist und Eintragen dieser Verknüpfungen in verschiedene 60er-Felder START + //////////////////////////// + + switch ( docChild.getType().id ) + { + case "DBERA": + case "DBETR": + case "DDAUE": + case "DDEBD": + case "DFIBU": + case "DABSC": + case "DLOHN": + case "DLSTD": + case "DSTEU": + def ueberdoks = d3.call.link_get_parents( docChild.id, "Master" ); + + def ziel_dok_ids = ""; + + ueberdoks.each + { + xlog( d3, 4, " Kind: " + docChild.id + " Elternelement: " + it ); + + ziel_dok_ids = ziel_dok_ids + "'" + it + "',"; + } + ziel_dok_ids = ziel_dok_ids.substring( 0, ziel_dok_ids.length( ) - 1 ); + + xlog( d3, 2, "Ziel-Dok_IDs: " + ziel_dok_ids ); + + def STATEMENT = "select dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_10, dok_dat_feld_13, dok_dat_feld_21 from firmen_spezifisch where doku_id in ( " + ziel_dok_ids + " ) "; + + def resultRows = d3.sql.executeAndGet( STATEMENT ); + + if ( resultRows.size() > 0 ) + { + // Schreiben der Verknüpfungen an das Dokument: + + def currentDoc = d3.archive.getDocument( docChild.id ); + + // Die Felder werden vor dem Füllen geleert, damit - für den Fall, dass weniger neue Werte reingeschrieben werden als vorher drin waren - keine + // deplazierten Restwerte in den Feldern stehen bleiben. (Könnte man vielleicht auch eleganter lösen.) + // Felder leeren: + for ( int i = 1 ; i <= Integer.valueOf( d3.config.value( "CUR_60ER_FIELD_NR" ) ); i++ ) + { + currentDoc.field[ 60 ][ i ] = ""; // Mandantennamen + currentDoc.field[ 61 ][ i ] = ""; // Mandantennummern + currentDoc.field[ 62 ][ i ] = ""; // Mandantengruppennummern + currentDoc.field[ 63 ][ i ] = ""; // Aktennamen + currentDoc.field[ 64 ][ i ] = ""; // Aktennummern + } + + // Jetzt Felder füllen mit den gefundenen Werten: + for ( int j = 1 ; j <= resultRows.size(); j++ ) + { + currentDoc.field[ 60 ][ j ] = resultRows[ j - 1 ].dok_dat_feld_2; // Mandantennamen + currentDoc.field[ 61 ][ j ] = resultRows[ j - 1 ].dok_dat_feld_1; // Mandantennummern + currentDoc.field[ 62 ][ j ] = resultRows[ j - 1 ].dok_dat_feld_13; // Mandantengruppennummern + currentDoc.field[ 63 ][ j ] = resultRows[ j - 1 ].dok_dat_feld_21; // Aktennamen + currentDoc.field[ 64 ][ j ] = resultRows[ j - 1 ].dok_dat_feld_10; // Aktennummern + } + + currentDoc.updateAttributes( "Master" ); + + } + + break; + + + } + + //////////////////////////// + // Feststellen, wo das Dokument überall verknüpft ist und Eintragen dieser Verknüpfungen in verschiedene 60er-Felder ENDE + //////////////////////////// + + + + //xlog( d3, 4, "1 *********************************************************" ); + //xlog( d3, 4, "hook_link_exit_10: " + docFather.id + " / " + docFather.getType().id + " => " + docChild.id + " / " + docChild.getType().id + " ENDE " ); + //xlog( d3, 4, "Mandatenakte " + docChild.field[ 1 ] + " / " + docChild.field[ 2 ] ); + + + return 0; + + } + + + + + + + + + + + + public static int createTask( D3Interface d3, User user, DocumentType docType, Document doc, String subject, String description, ArrayList assignees, String baseUri, String authUsr, String repo_id ) + { + //d3.log.info( "createTask !" ); + String assigneesString = ""; + + assignees.each + { + assigneesString = assigneesString + "\"${it}\","; + } + + if ( assigneesString.length() > 0 ) + { + assigneesString = assigneesString.substring(0, assigneesString.length()-1); + } + + CloseableHttpClient client = HttpClientBuilder.create( ).build( ); + + try + { + + UUID uuid = UUID.randomUUID(); + String randomUUIDString = uuid.toString(); + + //Post Task + HttpPost post = new HttpPost( baseUri + "/task/tasks" ); + + def ddf4; + if ( doc.field[ 4 ] == null ) + { + ddf4 = ""; + } + else + { + ddf4 = doc.field[ 4 ]; + } + + def ddf23; + if ( doc.field[ 23 ] == null ) + { + ddf23 = ""; + } + else + { + ddf23 = doc.field[ 23 ]; + } + + def ddf17; + if ( doc.field[ 17 ] == null ) + { + ddf17 = ""; + } + else + { + ddf17 = doc.field[ 17 ]; + } + + def ddf32; + if ( doc.field[ 32 ] == null ) + { + ddf32 = ""; + } + else + { + ddf32 = doc.field[ 32 ]; + } + + //JSON Inhalt + + def lJsonString = """{ + "subject" : "${subject}", + "description" : "${description}", + "assignees" : [${assigneesString}], + "correlationKey" : "${randomUUIDString}", + "context" : { + "key" : "returnProcess", + "type" : "process", + "name" : "Import in Akte" + }, + "metadata" : [ + { + "key" : "mandantname", + "caption" : "__Mandantname", + "values" : ["${doc.field[2]}"] + }, + { + "key" : "aktennummer", + "caption": "__Aktennummer", + "values" : ["${doc.field[10]}"] + }, + { + "key" : "oberregister", + "caption" : "_Oberregister", + "values" : ["${doc.field[3]}"] + }, + { + "key" : "register", + "caption" : "_Register", + "values" : ["${ddf4}"] + }, + { + "key" : "unterregister", + "caption" : "_Unterregister", + "values" : ["${ddf23}"] + }, + { + "key" : "unterregister2", + "caption" : "2. Unterregister", + "values" : ["${ddf17}"] + }, + { + "key" : "unterregister3", + "caption" : "3. Unterregister", + "values" : ["${ddf32}"] + } + ], + "_links" : { + "attachment" : { "href": "/dms/r/${repo_id}/o2/${doc.id()}"} + } + }"""; + + StringEntity params = new StringEntity( lJsonString, StandardCharsets.UTF_8 ); + params.setContentType("application/json"); + + post.addHeader("authorization", "Bearer ${authUsr}"); + post.addHeader("content-type", "application/json"); + post.addHeader("origin", baseUri ); + post.setEntity( params ); + CloseableHttpResponse response = client.execute( post ); + + try + { + def statusCode = response.getStatusLine( ).getStatusCode( ); + + if( statusCode != 200 && statusCode != "200" && statusCode != 201 && statusCode != "201" ) + { + HttpEntity re = response.getEntity(); + def lErrMsg = "createOfficeTaskFinished - Error while trying to create Task! Status Code: " + statusCode + " / Response: " + re.getContent().text; + d3.log.info( "createOfficeTaskFinished" + "" + lErrMsg + " -> " + lJsonString); + } + } + finally + { + response.close(); + } + } + catch ( Exception e ) + { + d3.log.error( "createOfficeTaskFinished" + "" + e.getMessage() ); + } + finally + { + client.close(); + } + + return 0; + } + + + + + + + public String getUserIdpId( D3Interface d3, String UserName, String repo_id, String baseUri, String authUserApiKey ) + { + + CloseableHttpClient client = HttpClientBuilder.create( ).build( ); + String userId; + + try + { + //https://d3one-test.kleeberg.kleeberg.de/identityprovider/scim/users?filter=userName%20eq%20kleeberg%5Cdvelop + HttpGet get = new HttpGet( baseUri + "/identityprovider/scim/users?filter=userName%20eq%20kleeberg%5C" + UserName ); + + //JSON Inhalt + get.addHeader( "authorization", "Bearer " + authUserApiKey ); + get.addHeader( "origin", baseUri ); + get.addHeader( "Accept", "application/json" ); + + CloseableHttpResponse response = client.execute( get ); + + + + try + { + def statusCode = response.getStatusLine( ).getStatusCode( ); + + if( statusCode != 200 && statusCode != 201 ){ + d3.log.error("getUserIdpId -> Error while trying to read user " + UserName + " status code: " + statusCode ); + + HttpEntity re = response.getEntity(); + InputStream errStream = re.getContent(); + String errContent = ""; + + if( errStream != null && errStream.available() > 0 ){ + errContent = IOUtils.toString(errStream, StandardCharsets.UTF_8); + } + + d3.log.error("getUserIdpId -> Error while trying to read user " + UserName + " response line: " + errContent); + + return ""; + } + + HttpEntity entity = response.getEntity( ); + + String json = EntityUtils.toString( entity, StandardCharsets.UTF_8 ); + + def jsonSlurper = new JsonSlurper(); + + def returnwert = jsonSlurper.parseText( json ); + + userId = returnwert.resources.id[ 0 ]; + + + } + finally + { + response.close(); + } + } + catch ( IOException e ) + { + e.printStackTrace(); + } + finally + { + try + { + client.close(); + } + catch (IOException e) + { + e.printStackTrace(); + } + } + + return userId; + + } + + + public int xlog( D3Interface d3, int loglevel, String logtext ) + { + def logdatei = "d:\\d3\\apps\\d3log.txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; + } + + + public int doclog( D3Interface d3, int loglevel, String logtext ) + { + def logdatei = "d:\\d3\\apps\\doc_import_zeitpunkte.txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; + } + + + + + + +} \ No newline at end of file diff --git a/Kleeberg/ERwflProcessConstants.groovy b/Kleeberg/ERwflProcessConstants.groovy new file mode 100644 index 0000000..fec09e6 --- /dev/null +++ b/Kleeberg/ERwflProcessConstants.groovy @@ -0,0 +1,24 @@ +public class ERwflProcessConstants{ + + // Base-Uri without trailing "/" + static final String gBaseUri = "https://d3one.kleeberg.kleeberg.de"; + + // API-Key of a user with the right to start a process. It is recommended to use a user without d.3 document permissions + static final String gApiKey = "BkelbC0cc2uf1PZ4Aftzvtw/tQKsUR7AGbj0/IrTDl/wIu34gyX4LWWU4NUkTDYEWF9uOfpxTIwn48fke1xzs8jJ5/dXf5ABBWRhuff/Z3U=&_z_A0V5ayCSDIwDiNS1nL5awyU2f_-oPqbOvu-W7spr3dMu6-RJODofIJ5nAN5pPh6GH3hdFbitxB2cXYhhUspF1O2Bu33Qq"; + + // Process ID + static final String gProzessId = "Eingangsrechnungsworkflow"; + + // Repository ID + static final String gRepoId = "7b813cf7-9909-54ba-a333-f62d302fdfdc"; + + // Dokumenttype used within the Hook-Definition + static final String gDocType = "DEREC" + + // Assignee group for first Task + //static final String gBuchhaltung = "identity://" + "/identityprovider/scim/groups/dd1cbb6d-8603-4ffd-a666-f0d61c9502df"; //ID ist von der Gruppe D3T_BUHA + static final String gBuchhaltung = "identity://" + "/identityprovider/scim/groups/7a37a8d3-45ff-46fa-9b3a-451681f7ac95"; //ID ist von der Gruppe D3T_BUHA_ER (Laut Fehlerliste soll hier eine Umstellung auf die Gruppe D3T_BUHA_ER umgestellt werden) + + // Subject first Task + static final String gSubject = "Eingangsrechnungsworkflow initial zur weiteren Bearbeitung prüfen"; +} \ No newline at end of file diff --git a/Kleeberg/EingangsrechnungsWorkflow.groovy b/Kleeberg/EingangsrechnungsWorkflow.groovy new file mode 100644 index 0000000..266058b --- /dev/null +++ b/Kleeberg/EingangsrechnungsWorkflow.groovy @@ -0,0 +1,89 @@ +// Hooks +import com.dvelop.d3.server.* +import com.dvelop.d3.server.core.D3Interface + +// REST / Http +import javax.net.ssl.HttpsURLConnection +import groovy.json.JsonSlurper + + +class Eingangsrechnungsworkflow { + + // Constructor + Eingangsrechnungsworkflow() {} + + @Entrypoint(entrypoint = "hook_insert_exit_30") + @Condition(doctype = [ERwflProcessConstants.gDocType]) + int ProcessInsertExit30_1(D3Interface d3, Document doc, String fileDestination, Integer importOk, User d3User, DocumentType docType){ + + def processId = ERwflProcessConstants.gProzessId; + def baseUri = ERwflProcessConstants.gBaseUri; + def repoId = ERwflProcessConstants.gRepoId; + def docId = doc.id; + def subject = ERwflProcessConstants.gSubject; + def empfaengerBuchhaltung = ERwflProcessConstants.gBuchhaltung; + def date = new Date(); + def timeString = date.getDateTimeString(); + def businessKey = "${processId}-${timeString}-${docId}"; + businessKey = businessKey.replaceAll(" ", ""); + + + def jsonBody = """{ + "businessKey": "${businessKey}", + "variables": { + "empfaengerBuchhaltung" : "${empfaengerBuchhaltung}", + "formInstanceId" : "${businessKey}", + "baseUri" : "${baseUri}", + "docId" : "${docId}", + "repoId" : "${repoId}", + "subject" : "${subject}", + "dv_attachment": "dmsObject:///dms/r/${repoId}/o2/${docId}" + } + }""" + + def migrationDoc = doc.field[48]; + + if ( migrationDoc == null || migrationDoc == "" ){ + d3.log.info("ProcessInsertExit30_1 - Groovy hook insert_exit_30_1 " + doc.id + processId); + + validateGenericProcessStart( d3, doc, d3User, processId, jsonBody ); + } + return 0 + } + + public static def validateGenericProcessStart(D3Interface d3, Document doc, User d3User, def processId, def jsonBody ) { + + try { + def body = jsonBody; + + def http = new URL( ERwflProcessConstants.gBaseUri + "/process/processes/" + processId + "/instances").openConnection() as HttpsURLConnection + http.setRequestMethod('POST') + http.setDoOutput(true) + http.setRequestProperty("Content-Type", "application/json; charset=utf-8") + http.setRequestProperty("Authorization", "Bearer " + ERwflProcessConstants.gApiKey ) + http.setRequestProperty("Accept-Charset" , "utf-8") + + http.outputStream.write(body.getBytes("UTF-8")) + http.connect() + + def response = [:] + + if (http.responseCode == 200 || http.responseCode == 201) { + def location = http.getHeaderField("location"); + d3.log.info("Process was started: " + location); + d3.log.info("Process was started on: " + http); + d3.log.info("Process was started on baseUri: " + ERwflProcessConstants.gBaseUri ); + } else { + response = http.getResponseMessage() + d3.log.error("Error while starting process: " + response + "(" + http.responseCode + ")"); + d3.log.error("POST-Request send: " + http + "(" + http.responseCode + ")"); + return -1; + } + } catch (Exception e) { + d3.log.error("Exception while starting process: " + e.getMessage()); + return -1; + } + + return 0; + } +} diff --git a/Kleeberg/mehrfachfelder_einrichten.groovy b/Kleeberg/mehrfachfelder_einrichten.groovy new file mode 100644 index 0000000..0dfefea --- /dev/null +++ b/Kleeberg/mehrfachfelder_einrichten.groovy @@ -0,0 +1,270 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "mehrfachfelder_einrichten.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + + +// Dieses Skript soll bei allen Dokumenten innerhalb der Mandatenakte die verknüpften Akten in 60er-Felder eintragen, damit die Dokumente bei einer passenden Suche gefunden werden. +// Dabei wird festgehalten, welche Dokumente bereits aktualisiert wurden. + + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + +@Field suffix = Math.abs( new Random().nextInt() % (99999 - 10000) ) + 10000; + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + +def i, ergebniszeilen, ergebnistext; + +def dokumentarten = "'DBERA', 'DBETR', 'DDAUE', 'DDEBD', 'DFIBU', 'DABSC', 'DLOHN', 'DLSTD', 'DSTEU' "; + + +def sqlQuery = "select top (10000) doku_id, kue_dokuart from firmen_spezifisch where kue_dokuart in ( " + dokumentarten + " ) and doku_id not in ( select doku_id from dv_mehrf_feld) order by kue_dokuart"; + +DB_Zeilen = d3.sql.executeAndGet( (String) sqlQuery ); + +if ( DB_Zeilen.size() > 0 ) +{ + xlog( d3, 4, " Es wurde(n) " + DB_Zeilen.size() + " Treffer gefunden." ); + xlog( d3, 4, "************************************************" ); + + for ( i = 0; i < DB_Zeilen.size(); i++ ) + { + def docChild = DB_Zeilen[ i ].doku_id; + + xlog( d3, 4, i + ": bearbeite Doku-ID " + docChild ); + + def ueberdoks = d3.call.link_get_parents( docChild, "Master" ); + //xlog( d3, 4, i + ": bearbeite ueberdoks-ID " + ueberdoks + " " + ueberdoks.size() ); + + def ziel_dok_ids = ""; + if ( ueberdoks.size() > 0 ) + { + ueberdoks.each + { + xlog( d3, 4, i + ": => Kind: " + docChild + " Elternelement: " + it ); + + ziel_dok_ids = ziel_dok_ids + "'" + it + "',"; + } + + ziel_dok_ids = ziel_dok_ids.substring( 0, ziel_dok_ids.length( ) - 1 ); + + xlog( d3, 4, i + ": Ziel-Dok_IDs: " + ziel_dok_ids ); + + def STATEMENT = "select kue_dokuart, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_10, dok_dat_feld_13, dok_dat_feld_21 from firmen_spezifisch where doku_id in ( " + ziel_dok_ids + " ) "; + + def resultRows = d3.sql.executeAndGet( STATEMENT ); + + if ( resultRows.size() > 0 ) + { + // Schreiben der Verknüpfungen an das Dokument: + + def currentDoc = d3.archive.getDocument( docChild ); + + // Die Felder werden vor dem Füllen geleert, damit - für den Fall, dass weniger neue Werte reingeschrieben werden als vorher drin waren - keine + // deplazierten Restwerte in den Feldern stehen bleiben. (Könnte man vielleicht auch eleganter lösen.) + // Felder leeren: + for ( int m = 1 ; m <= Integer.valueOf( d3.config.value( "CUR_60ER_FIELD_NR" ) ); m++ ) + { + currentDoc.field[ 60 ][ m ] = ""; // Mandantennamen + currentDoc.field[ 61 ][ m ] = ""; // Mandantennummern + currentDoc.field[ 62 ][ m ] = ""; // Mandantengruppennummern + currentDoc.field[ 63 ][ m ] = ""; // Aktennamen + currentDoc.field[ 64 ][ m ] = ""; // Aktennummern + } + + // Jetzt Felder füllen mit den gefundenen Werten: + for ( int j = 1 ; j <= resultRows.size(); j++ ) + { + currentDoc.field[ 60 ][ j ] = resultRows[ j - 1 ].dok_dat_feld_2; // Mandantennamen + currentDoc.field[ 61 ][ j ] = resultRows[ j - 1 ].dok_dat_feld_1; // Mandantennummern + currentDoc.field[ 62 ][ j ] = resultRows[ j - 1 ].dok_dat_feld_13; // Mandantengruppennummern + currentDoc.field[ 63 ][ j ] = resultRows[ j - 1 ].dok_dat_feld_21; // Aktennamen + currentDoc.field[ 64 ][ j ] = resultRows[ j - 1 ].dok_dat_feld_10; // Aktennummern + xlog( d3, 4, i + ": Dokument " + docChild + ": Info-Zeile " + j + " gesetzt: <" + resultRows[ j - 1 ].kue_dokuart + "> <" + resultRows[ j - 1 ].dok_dat_feld_2 + "> <" + resultRows[ j - 1 ].dok_dat_feld_1 + "> <" + resultRows[ j - 1 ].dok_dat_feld_13 + "> <" + resultRows[ j - 1 ].dok_dat_feld_21 + "> <" + resultRows[ j - 1 ].dok_dat_feld_10 + ">" ); + } + + currentDoc.updateAttributes( "Master" ); + dokument_fertig( d3, docChild, "Aktualisierung erfolgt." ); + xlog( d3, 4, i + ": Dokument " + docChild + ": Aktualisierung erfolgt." ); + } + + } + else + { + dokument_fertig( d3, docChild, "keine uebergeordneten Akten" ); + xlog( d3, 3, i + ": Dokument " + docChild + " hat keine uebergeordneten Akten." ); + } + xlog( d3, 4, "************************************************" ); + } + + +} +else +{ + xlog( d3, 3, "Es wurden keine passenden Treffer gefunden!" ); +} + + + + + + + + + + + + + + + + +def dokument_fertig( D3Interface d3, String doku_id, String meldung ) +{ + def meldung_db; + + if ( meldung.length() > 200 ) + { + meldung_db = meldung.substring( 0, 199 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + //xlog( d3, 4, "Angekommen" ); + sql = "insert into dv_mehrf_feld (doku_id, status) values ( '" + doku_id + "', '" + meldung + "' )"; + d3.sql.execute( sql ); + } + + +} + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\logs\\" + prg + "_" + suffix + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} \ No newline at end of file diff --git a/Kleeberg/migration_akte_ausgangsrechakte.groovy b/Kleeberg/migration_akte_ausgangsrechakte.groovy new file mode 100644 index 0000000..57d6221 --- /dev/null +++ b/Kleeberg/migration_akte_ausgangsrechakte.groovy @@ -0,0 +1,594 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte_ausgangsrechakte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_ausgangsrechnungsakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "AMAND"; +@Field dokuart_hauptakte = "AAURE"; +@Field dokuart_oberregisterakte = "AAURR"; +@Field dokuart_registerakte = "AAURA"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Ausgangsrechnungsakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Ausgangsrechnungsakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null"; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingefügt, da der Vergleich sonst scheitert. + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingefügt, da sonst später beim wegschreiben ein Java-Class-Error auftritt. + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert doku_id: [" + ergebnis[ 0 ].doku_id + "]", (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + newDocOReg.field[ 37 ] = newDocfield_37; + newDocOReg.field[ 42 ] = newDocfield_42; + + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + newDocReg.field[ 37 ] = newDocfield_37; + newDocReg.field[ 42 ] = newDocfield_42; + + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_beratungsakte korrektur doppelte Aktennummern.groovy b/Kleeberg/migration_akte_beratungsakte korrektur doppelte Aktennummern.groovy new file mode 100644 index 0000000..fb361a6 --- /dev/null +++ b/Kleeberg/migration_akte_beratungsakte korrektur doppelte Aktennummern.groovy @@ -0,0 +1,586 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_beratungsakten"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "ABESA"; +@Field dokuart_hauptakte = "ABERB"; +@Field dokuart_oberregisterakte = "ABERO"; +@Field dokuart_registerakte = "ABERA"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Beratungsakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Beratungsakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69 from " + zieltabelle + " where fehler ='Doppelte Aktennummer'"; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingefügt, da der Vergleich sonst scheitert. + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingefügt + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_beratungsakte_1.groovy b/Kleeberg/migration_akte_beratungsakte_1.groovy new file mode 100644 index 0000000..f70890c --- /dev/null +++ b/Kleeberg/migration_akte_beratungsakte_1.groovy @@ -0,0 +1,586 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_beratungsakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "ABESA"; +@Field dokuart_hauptakte = "ABERB"; +@Field dokuart_oberregisterakte = "ABERO"; +@Field dokuart_registerakte = "ABERA"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Beratungsakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Beratungsakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null and id < 7000 "; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingefügt, da der Vergleich sonst scheitert. + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingefügt + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + "_1.txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_beratungsakte_2.groovy b/Kleeberg/migration_akte_beratungsakte_2.groovy new file mode 100644 index 0000000..6fcddf0 --- /dev/null +++ b/Kleeberg/migration_akte_beratungsakte_2.groovy @@ -0,0 +1,586 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_beratungsakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "ABESA"; +@Field dokuart_hauptakte = "ABERB"; +@Field dokuart_oberregisterakte = "ABERO"; +@Field dokuart_registerakte = "ABERA"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Beratungsakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Beratungsakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null and id >= 7000 and id < 14000 "; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingefügt, da der Vergleich sonst scheitert. + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingefügt + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + "_2.txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_beratungsakte_3.groovy b/Kleeberg/migration_akte_beratungsakte_3.groovy new file mode 100644 index 0000000..b8899c7 --- /dev/null +++ b/Kleeberg/migration_akte_beratungsakte_3.groovy @@ -0,0 +1,586 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_beratungsakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "ABESA"; +@Field dokuart_hauptakte = "ABERB"; +@Field dokuart_oberregisterakte = "ABERO"; +@Field dokuart_registerakte = "ABERA"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Beratungsakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Beratungsakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null and id >= 14000 "; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingefügt, da der Vergleich sonst scheitert. + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingefügt + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + "_3.txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_betriebspruefungsakte.groovy b/Kleeberg/migration_akte_betriebspruefungsakte.groovy new file mode 100644 index 0000000..2d98ca1 --- /dev/null +++ b/Kleeberg/migration_akte_betriebspruefungsakte.groovy @@ -0,0 +1,591 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_betriebspruefungsakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "ABPSA"; +@Field dokuart_hauptakte = "ABETR"; +@Field dokuart_oberregisterakte = "ABEOR"; +@Field dokuart_registerakte = "ABEPA"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Betriebspruefungsakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Betriebspruefungsakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null"; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL ToString eingefügt + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + ///JFEL toString eingebaut + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_dauerakte.groovy b/Kleeberg/migration_akte_dauerakte.groovy new file mode 100644 index 0000000..96524a5 --- /dev/null +++ b/Kleeberg/migration_akte_dauerakte.groovy @@ -0,0 +1,671 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte_dauerakte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_dauerakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "AMAND"; //Es gibt keine Sammelakte fuer Dauerakten, daher werden die Infos aus der Mandantenakte ermittelt +@Field dokuart_hauptakte = "ADAUR"; +@Field dokuart_oberregisterakte = "AOREG"; +@Field dokuart_registerakte = "AREGS"; +@Field dokuart_unterregisterakte = "AUREG"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Dauerakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Dauerakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null"; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + + //JFEL toString eingefügt, da der Vergleich sonst scheitert. + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_48, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingefügt, da sonst später beim wegschreiben ein Java-Class-Error auftritt. + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 37 ] = newDocfield_37; + newDocOReg.field[ 42 ] = newDocfield_42; + + + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 37 ] = newDocfield_37; + newDocReg.field[ 42 ] = newDocfield_42; + + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Unterregister + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3, dok_dat_feld_4 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_4 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "][" + it.dok_dat_feld_4 + "]" ); + + Document newDocUReg = d3.archive.newDocument(); + + newDocUReg.type = dokuart_unterregisterakte; + + newDocUReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocUReg.editor = "dvelop"; + + newDocUReg.field[ 1 ] = newDocfield_1; + newDocUReg.field[ 2 ] = newDocfield_2; + newDocUReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocUReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocUReg.field[ 10 ] = newDocfield_10; + newDocUReg.field[ 13 ] = newDocfield_13; + newDocUReg.field[ 21 ] = newDocfield_21; + newDocUReg.field[ 23 ] = it.dok_dat_feld_4; // Unterregister + newDocUReg.field[ 25 ] = newDocfield_25; + newDocUReg.field[ 37 ] = newDocfield_37; + newDocUReg.field[ 42 ] = newDocfield_42; + + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocUReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocUReg = d3.archive.importDocument( newDocUReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "][" + it.dok_dat_feld_4 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "][" + it.dok_dat_feld_4 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "' and dok_dat_feld_23 = '" + it.dok_dat_feld_4 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocUReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Mandantenakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_eigenverwaltung.groovy b/Kleeberg/migration_akte_eigenverwaltung.groovy new file mode 100644 index 0000000..e411a45 --- /dev/null +++ b/Kleeberg/migration_akte_eigenverwaltung.groovy @@ -0,0 +1,336 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_eigenverwaltungsakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = ""; +@Field dokuart_hauptakte = "AEVAK"; +@Field dokuart_oberregisterakte = "AEVOR"; +@Field dokuart_registerakte = "AEVRE"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Eigenverwaltungsakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Beratungsakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf48,ddf10,ddf21,ddf25,ddf60,ddf69,ddf41 from " + zieltabelle + " where fehler is null and doku_id is null"; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + + // Es wird eine neue Hauptakte erstellt + + def newDocfield_10, newDocfield_21, newDocfield_25, newDocfield_41, newDocfield_48, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF41 : [" + treffer[ i ].ddf41 + "]" ); + newDocfield_41 = treffer[ i ].ddf41; + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + // Eigenverwaltungsakten haben keine Sammelakten, daher ist der Part entfernt worden + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 41 ] = newDocfield_41; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + // Eigenverwaltungsakten haben keine fest definierte Unterstruktur, daher ist der Code hier entfernt worden + + xlog( d3, 4, "************************************************" ); + + + } + + +} + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_fibuakte.groovy b/Kleeberg/migration_akte_fibuakte.groovy new file mode 100644 index 0000000..ab6fed9 --- /dev/null +++ b/Kleeberg/migration_akte_fibuakte.groovy @@ -0,0 +1,599 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_finanzbuchhaltungsakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "AFBSA"; +@Field dokuart_hauptakte = "AFIBA"; +@Field dokuart_oberregisterakte = "AFIOR"; +@Field dokuart_registerakte = "AFIRA"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Finanzbuchhaltungs-Akte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Fibuakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf5,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null"; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + xlog( d3, 4, "Mandantnummer aus Aktennummer = " + mandantnr_aus_aktennr ); + xlog( d3, 4, "Mandantnummer aus Datenbank = " + treffer[ i ].ddf1 ); + + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_5, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_48, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + newDocfield_1 = treffer[ i ].ddf1; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + if ( treffer[ i ].ddf5 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + treffer[ i ].ddf5 + "]" ); + newDocfield_5 = treffer[ i ].ddf5; + } + else + { + def ddf5neu = treffer[ i ].ddf10.substring( treffer[ i ].ddf10.indexOf( 'FI' ) + 2, treffer[ i ].ddf10.indexOf( 'FI' ) + 6 ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + ddf5neu + "]" ); + newDocfield_5 = ddf5neu; + } + + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 5 ] = newDocfield_5; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 5 ] = newDocfield_5; + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 5 ] = newDocfield_5; + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_jahresabschlussakte_1.groovy b/Kleeberg/migration_akte_jahresabschlussakte_1.groovy new file mode 100644 index 0000000..e9a130b --- /dev/null +++ b/Kleeberg/migration_akte_jahresabschlussakte_1.groovy @@ -0,0 +1,601 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_jahresabschlussakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "AJASA"; +@Field dokuart_hauptakte = "AJAAA"; +@Field dokuart_oberregisterakte = "AJAOB"; +@Field dokuart_registerakte = "AJAAB"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Jahresabschlussakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Jahresabschlussakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null and id < 7000 "; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingebaut + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_5, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_48, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingebaut + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; +//Auskommentiert, da aktuell das ddf5, also das Geschaeftsjahr, nicht in der Tabelle mitgeliefert wird +// if ( treffer[ i ]?.ddf5 ) +// { +// xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + treffer[ i ].ddf5 + "]" ); +// newDocfield_5 = treffer[ i ].ddf5; +// } +// else +// { + def ddf5neu = treffer[ i ].ddf10.substring( treffer[ i ].ddf10.indexOf( 'JA' ) + 2, treffer[ i ].ddf10.indexOf( 'JA' ) + 6 ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + ddf5neu + "]" ); + newDocfield_5 = ddf5neu; +// } + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 5 ] = newDocfield_5; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 5 ] = newDocfield_5; + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 5 ] = newDocfield_5; + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + "_1.txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_jahresabschlussakte_2.groovy b/Kleeberg/migration_akte_jahresabschlussakte_2.groovy new file mode 100644 index 0000000..39c2b36 --- /dev/null +++ b/Kleeberg/migration_akte_jahresabschlussakte_2.groovy @@ -0,0 +1,601 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_jahresabschlussakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "AJASA"; +@Field dokuart_hauptakte = "AJAAA"; +@Field dokuart_oberregisterakte = "AJAOB"; +@Field dokuart_registerakte = "AJAAB"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Jahresabschlussakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Jahresabschlussakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null and id >= 7000 "; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingebaut + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_5, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_48, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingebaut + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; +//Auskommentiert, da aktuell das ddf5, also das Geschaeftsjahr, nicht in der Tabelle mitgeliefert wird +// if ( treffer[ i ]?.ddf5 ) +// { +// xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + treffer[ i ].ddf5 + "]" ); +// newDocfield_5 = treffer[ i ].ddf5; +// } +// else +// { + def ddf5neu = treffer[ i ].ddf10.substring( treffer[ i ].ddf10.indexOf( 'JA' ) + 2, treffer[ i ].ddf10.indexOf( 'JA' ) + 6 ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + ddf5neu + "]" ); + newDocfield_5 = ddf5neu; +// } + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 5 ] = newDocfield_5; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 5 ] = newDocfield_5; + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 5 ] = newDocfield_5; + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + "_2.txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_kreditorenakte.groovy b/Kleeberg/migration_akte_kreditorenakte.groovy new file mode 100644 index 0000000..6492806 --- /dev/null +++ b/Kleeberg/migration_akte_kreditorenakte.groovy @@ -0,0 +1,527 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_kreditorenakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = ""; +@Field dokuart_hauptakte = "AKRED"; +@Field dokuart_oberregisterakte = "AKROR"; +@Field dokuart_registerakte = "AKRER"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Kreditorakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Kreditorenakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf48,ddf10,ddf20,ddf19,ddf22,ddf62,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null"; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + if ( mandantnr_aus_aktennr == treffer[ i ].ddf19 ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_19, newDocfield_10, newDocfield_20, newDocfield_22, newDocfield_48, newDocfield_62 = [ ], newDocfield_69 = [ ]; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Kreditornummer DDF19 : [" + treffer[ i ].ddf19 + "]" ); + newDocfield_19 = treffer[ i ].ddf19; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Kreditorname DDF20 : [" + treffer[ i ].ddf20 + "]" ); + newDocfield_20 = treffer[ i ].ddf20; + + def dddf22 = "Digital"; + + if ( ( ! treffer[ i ].ddf22 ) || ( treffer[ i ].ddf22 == 'null' ) ) + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": physischer Aufbewahrungsort DDF22 wurde nicht angegeben, default: [" + dddf22 + "]" ); + } + else + { + dddf22 = treffer[ i ].ddf22; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + dddf22 + "]" ); + newDocfield_22 = dddf22; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Freigeber + if ( treffer[ i ].ddf62 ) + { + def splitted_str_array = treffer[ i ].ddf62.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF62 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_62[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + //sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + //ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( true ) + { + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_RELEASE; + //newDoc.editor = "dvelop"; + + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 19 ] = newDocfield_19; + newDoc.field[ 20 ] = newDocfield_20; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_62.size(); i++ ) + { + newDoc.field[ 62 ][ i + 1 ] = newDocfield_62[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_19 = '" + newDocfield_19 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: [" + ergebnis[ 0 ].doku_id + "]" ); + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert. doku_id: [" + ergebnis[ 0 ].doku_id + "]", (int) treffer[ i ].id ); + xlog( d3, 4, "************************************************" ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_RELEASE; + //newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 19 ] = newDocfield_19; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 20 ] = newDocfield_20; + newDocOReg.field[ 22 ] = newDocfield_22; + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_RELEASE; + //newDocReg.editor = "dvelop"; + + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 19 ] = newDocfield_19; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 20 ] = newDocfield_20; + newDocReg.field[ 22 ] = newDocfield_22; + newDocReg.field[ 4 ] = it.dok_dat_feld_4; // Register + + + + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Kreditornummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_kreditorenakte_2.groovy b/Kleeberg/migration_akte_kreditorenakte_2.groovy new file mode 100644 index 0000000..e09a0dd --- /dev/null +++ b/Kleeberg/migration_akte_kreditorenakte_2.groovy @@ -0,0 +1,527 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_kreditorenakte_2"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = ""; +@Field dokuart_hauptakte = "AKRED"; +@Field dokuart_oberregisterakte = "AKROR"; +@Field dokuart_registerakte = "AKRER"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Kreditorakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Kreditorenakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf48,ddf10,ddf20,ddf19,ddf22,ddf62,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null"; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + if ( mandantnr_aus_aktennr == treffer[ i ].ddf19 ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_19, newDocfield_10, newDocfield_20, newDocfield_22, newDocfield_48, newDocfield_62 = [ ], newDocfield_69 = [ ]; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Kreditornummer DDF19 : [" + treffer[ i ].ddf19 + "]" ); + newDocfield_19 = treffer[ i ].ddf19; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Kreditorname DDF20 : [" + treffer[ i ].ddf20 + "]" ); + newDocfield_20 = treffer[ i ].ddf20; + + def dddf22 = "Digital"; + + if ( ( ! treffer[ i ].ddf22 ) || ( treffer[ i ].ddf22 == 'null' ) ) + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": physischer Aufbewahrungsort DDF22 wurde nicht angegeben, default: [" + dddf22 + "]" ); + } + else + { + dddf22 = treffer[ i ].ddf22; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + dddf22 + "]" ); + newDocfield_22 = dddf22; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Freigeber + if ( treffer[ i ].ddf62 ) + { + def splitted_str_array = treffer[ i ].ddf62.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF62 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_62[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + //sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + //ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( true ) + { + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_RELEASE; + //newDoc.editor = "dvelop"; + + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 19 ] = newDocfield_19; + newDoc.field[ 20 ] = newDocfield_20; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_62.size(); i++ ) + { + newDoc.field[ 62 ][ i + 1 ] = newDocfield_62[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_19 = '" + newDocfield_19 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: [" + ergebnis[ 0 ].doku_id + "]" ); + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert. doku_id: [" + ergebnis[ 0 ].doku_id + "]", (int) treffer[ i ].id ); + xlog( d3, 4, "************************************************" ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_RELEASE; + //newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 19 ] = newDocfield_19; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 20 ] = newDocfield_20; + newDocOReg.field[ 22 ] = newDocfield_22; + + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_RELEASE; + //newDocReg.editor = "dvelop"; + + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 19 ] = newDocfield_19; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 20 ] = newDocfield_20; + newDocReg.field[ 22 ] = newDocfield_22; + newDocReg.field[ 4 ] = it.dok_dat_feld_4; // Register + + + + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Kreditornummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_lohnbuchhaltungsakte.groovy b/Kleeberg/migration_akte_lohnbuchhaltungsakte.groovy new file mode 100644 index 0000000..5dfae9c --- /dev/null +++ b/Kleeberg/migration_akte_lohnbuchhaltungsakte.groovy @@ -0,0 +1,601 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte_lohnbuchhaltungsakte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_lohnbuchhaltungsakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "ALOSA"; +@Field dokuart_hauptakte = "ALOJA"; +@Field dokuart_oberregisterakte = "ALBOR"; +@Field dokuart_registerakte = "ALBRE"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Lohnbuchhaltungs-Jahresakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Lohnbuchhaltungjahresakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf5,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null"; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingefügt + // if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_5, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingefügt + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + def dddf5; + + if ( ( ! treffer[ i ].ddf5 ) || ( treffer[ i ].ddf5 = 'null' ) ) + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Geschaeftsjahr in Tabelle nicht gefuellt, Lese Geschaeftsjahr aus Aktennummer." ); + dddf5 = newDocfield_10.substring( 7, 11 ); + } + else + { + dddf5 = treffer[ i ].ddf5; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + dddf5 + "]" ); + newDocfield_5 = dddf5; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 5 ] = newDocfield_5; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 5 ] = newDocfield_5; + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 5 ] = newDocfield_5; + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_lohnbuchhaltungsstammdatenakte.groovy b/Kleeberg/migration_akte_lohnbuchhaltungsstammdatenakte.groovy new file mode 100644 index 0000000..d0d98ef --- /dev/null +++ b/Kleeberg/migration_akte_lohnbuchhaltungsstammdatenakte.groovy @@ -0,0 +1,580 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 1; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_lohnbuchhaltungsstammakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "ALOSA"; +@Field dokuart_hauptakte = "ALBSA"; +@Field dokuart_oberregisterakte = "ALBSO"; +@Field dokuart_registerakte = "ALORE"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Lohnbuchhaltungs-Stammdatenakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Lohnbuchhaltungsstammdatenakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf5,ddf69 from " + zieltabelle + " where fehler is null and doku_id is null"; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_5, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + newDocfield_1 = treffer[ i ].ddf1; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + treffer[ i ].ddf5 + "]" ); + newDocfield_5 = treffer[ i ].ddf5; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 5 ] = newDocfield_5; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_steuerakte_1.groovy b/Kleeberg/migration_akte_steuerakte_1.groovy new file mode 100644 index 0000000..cdbfb36 --- /dev/null +++ b/Kleeberg/migration_akte_steuerakte_1.groovy @@ -0,0 +1,605 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte_steuerakte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_steuerakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "ASTSA"; +@Field dokuart_hauptakte = "ASTEU"; +@Field dokuart_oberregisterakte = "ASTOR"; +@Field dokuart_registerakte = "ASTRA"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Steuerakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Steuerakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69,ddf5 from " + zieltabelle + " where fehler is null and doku_id is null and id < 9000 "; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingebaut + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_5, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingebaut + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + def dddf5; + + if ( ( ! treffer[ i ].ddf5 ) || ( treffer[ i ].ddf5 = 'null' ) ) + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Geschaeftsjahr in Tabelle nicht gefuellt, Lese Geschaeftsjahr aus Aktennummer." ); + dddf5 = newDocfield_10.substring( 7, 11 ); + } + else + { + dddf5 = treffer[ i ].ddf5; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + dddf5 + "]" ); + newDocfield_5 = dddf5; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 5 ] = newDocfield_5; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: [" + ergebnis[ 0 ].doku_id + "]" ); + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 5 ] = newDocfield_5; + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 5 ] = newDocfield_5; + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + "_1.txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_steuerakte_2.groovy b/Kleeberg/migration_akte_steuerakte_2.groovy new file mode 100644 index 0000000..f255806 --- /dev/null +++ b/Kleeberg/migration_akte_steuerakte_2.groovy @@ -0,0 +1,605 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte_steuerakte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_steuerakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "ASTSA"; +@Field dokuart_hauptakte = "ASTEU"; +@Field dokuart_oberregisterakte = "ASTOR"; +@Field dokuart_registerakte = "ASTRA"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Steuerakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Steuerakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69,ddf5 from " + zieltabelle + " where fehler is null and doku_id is null and id >= 9000 and id < 18000 "; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingebaut + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_5, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingebaut + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + def dddf5; + + if ( ( ! treffer[ i ].ddf5 ) || ( treffer[ i ].ddf5 = 'null' ) ) + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Geschaeftsjahr in Tabelle nicht gefuellt, Lese Geschaeftsjahr aus Aktennummer." ); + dddf5 = newDocfield_10.substring( 7, 11 ); + } + else + { + dddf5 = treffer[ i ].ddf5; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + dddf5 + "]" ); + newDocfield_5 = dddf5; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 5 ] = newDocfield_5; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: [" + ergebnis[ 0 ].doku_id + "]" ); + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 5 ] = newDocfield_5; + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 5 ] = newDocfield_5; + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + "_2.txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_akte_steuerakte_3.groovy b/Kleeberg/migration_akte_steuerakte_3.groovy new file mode 100644 index 0000000..7af038b --- /dev/null +++ b/Kleeberg/migration_akte_steuerakte_3.groovy @@ -0,0 +1,605 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +def prg = "migration_akte_steuerakte.groovy"; +def version = "0.1"; +def kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + +// In welcher Tabelle soll nach den zu erstellenden Akten gesucht werden? +@Field zieltabelle = "mig_steuerakte"; + + +// Konfiguration der Aktenartkürzel +@Field dokuart_sammelakte = "ASTSA"; +@Field dokuart_hauptakte = "ASTEU"; +@Field dokuart_oberregisterakte = "ASTOR"; +@Field dokuart_registerakte = "ASTRA"; + + + +// der hier konfigurierte Wert wird verwendet, wenn kein sonstiger Hauptaktenname gefunden wird. +@Field standard_hauptaktenname = "Steuerakte"; + + +// DDF 1 / ADM_Aktentyp aus der Aktenart ADM_Verwaltung Mandantenakte (AVMNT) - mit diesem Schlüssel werden die benötigten (Ober-)Register aus den Stammdaten in der Aktenart AVMNT ermittelt. +@Field aktenschluessel = "Steuerakte"; + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); +xlog( d3, 4, "* Aktenart Sammelakte : " + dokuart_sammelakte ); +xlog( d3, 4, "* Aktenart Hauptakte : " + dokuart_hauptakte ); +xlog( d3, 4, "* Aktenart Oberregisterakte : " + dokuart_oberregisterakte ); +xlog( d3, 4, "* Aktenart Registerakte : " + dokuart_registerakte ); +xlog( d3, 4, "* Zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* Standard-Hauptaktenname : " + standard_hauptaktenname ); +xlog( d3, 4, "* Aktenschluessel : " + aktenschluessel ); + + + + +xlog( d3, 4, "************************************************" ); + + + + +def sqlQuery = "select top (100) id,ddf1,ddf48,ddf10,ddf21,ddf22,ddf25,ddf37,ddf42,ddf60,ddf69,ddf5 from " + zieltabelle + " where fehler is null and doku_id is null and id >= 18000 "; + +treffer = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + treffer.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( treffer.size() > 0 ) +{ + for ( i = 0; i < treffer.size(); i++ ) + { + // Prüfung, ob die Mandantnummer in der Aktennummer zu der Mandantnummer aus der Tabelle passt - andernfalls Fehler. + + def mandantnr_aus_aktennr = treffer[ i ].ddf10.substring( 0, 5 ); + + //JFEL toString eingebaut + //if ( mandantnr_aus_aktennr == treffer[ i ].ddf1 ) + if ( mandantnr_aus_aktennr == treffer[ i ].ddf1.toString() ) + { + // Es wird eine neue Hauptakte erstellt + + def newDocfield_1, newDocfield_2, newDocfield_5, newDocfield_10, newDocfield_13, newDocfield_21, newDocfield_22, newDocfield_25, newDocfield_37, newDocfield_42, newDocfield_60 = [ ], newDocfield_69 = [ ]; + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantennummer DDF1 : [" + treffer[ i ].ddf1 + "]" ); + + //JFEL toString eingebaut + //newDocfield_1 = treffer[ i ].ddf1; + newDocfield_1 = treffer[ i ].ddf1.toString(); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktennummer DDF10 : [" + treffer[ i ].ddf10 + "]" ); + newDocfield_10 = treffer[ i ].ddf10; + + def dddf5; + + if ( ( ! treffer[ i ].ddf5 ) || ( treffer[ i ].ddf5 = 'null' ) ) + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Geschaeftsjahr in Tabelle nicht gefuellt, Lese Geschaeftsjahr aus Aktennummer." ); + dddf5 = newDocfield_10.substring( 7, 11 ); + } + else + { + dddf5 = treffer[ i ].ddf5; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsjahr DDF5 : [" + dddf5 + "]" ); + newDocfield_5 = dddf5; + + if ( treffer[ i ].ddf21 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : [" + treffer[ i ].ddf21 + "]" ); + newDocfield_21 = treffer[ i ].ddf21; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenname wurde nicht gefunden. Setze Standardbezeichnung '" + standard_hauptaktenname + "'." ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Aktenname DDF21 : <" + standard_hauptaktenname + ">" ); + newDocfield_21 = standard_hauptaktenname; + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze physischer Aufbewahrungsort DDF22 : [" + treffer[ i ].ddf22 + "]" ); + newDocfield_22 = treffer[ i ].ddf22; + + if ( treffer[ i ].ddf25 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 : [" + treffer[ i ].ddf25 + "]" ); + newDocfield_25 = treffer[ i ].ddf25; + } + else + { + def STATEMENT = "select dok_dat_feld_25 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Geschaeftsfuehrer DDF25 aus M.-Akte : [" + treffer_STATEMENT[ 0 ].dok_dat_feld_25 + "]" ); + newDocfield_25 = treffer_STATEMENT[ 0 ].dok_dat_feld_25; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Geschaeftsfuehrer / DDF25 gefunden werden." ); + } + } + + if ( treffer[ i ].ddf37 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 : [" + treffer[ i ].ddf37 + "]" ); + newDocfield_37 = treffer[ i ].ddf37; + } + else + { + def STATEMENT = "select dok_dat_feld_37 from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + newDocfield_1 + "'"; + def treffer_STATEMENT = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( treffer_STATEMENT.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Auftragsverantwortlicher DDF37 aus M.-Akte: [" + treffer_STATEMENT[ 0 ].dok_dat_feld_37 + "]" ); + newDocfield_37 = treffer_STATEMENT[ 0 ].dok_dat_feld_37; + } + else + { + xlog( d3, 3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Es konnte kein Wert für Auftragsverantwortlicher / DDF37 gefunden werden." ); + } + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Briefkopf DDF42 : [" + treffer[ i ].ddf42 + "]" ); + newDocfield_42 = treffer[ i ].ddf42; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Unique-ID Migration DDF48 : [" + treffer[ i ].ddf48 + "]" ); + newDocfield_48 = treffer[ i ].ddf48; + + // Postempfänger + if ( treffer[ i ].ddf60 ) + { + def splitted_str_array = treffer[ i ].ddf60.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Postempfaenger DDF60 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_60[ j ] = splitted_str_array[ j ]; + } + } + + + // Berechtigter: + if ( treffer[ i ].ddf69 ) + { + def splitted_str_array = treffer[ i ].ddf69.split( ';' ); + for ( int j = 0; j < splitted_str_array.length; j++ ) + { + def filler = " "; + if ( j >= 10 ) + { + filler = ""; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Setze Berechtigter DDF69 / " + filler + j + " : [" + splitted_str_array[ j ] + "]" ); + newDocfield_69[ j ] = splitted_str_array[ j ]; + } + } + + + // Prüfung, ob zu dieser Hauptakte eine passende Sammelakte existiert + // Falls ja: Ãœbernahme der Mandantenstammdaten der entsprechenden Akte + // Falls nein: Fehler in DB eintragen und Abbruch der Verarbeitung dieses Treffers + + sqlQuery = "select doku_id, dok_dat_feld_1, dok_dat_feld_2, dok_dat_feld_13 from firmen_spezifisch where kue_dokuart = '" + dokuart_sammelakte + "' and dok_dat_feld_1 = '" + treffer[ i ].ddf1 + "'"; + + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( ergebnis.size() > 0 ) + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantenname DDF2 : [" + ergebnis[ 0 ].dok_dat_feld_2 + "]" ); + newDocfield_2 = ergebnis[ 0 ].dok_dat_feld_2; + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": setze Mandantengruppennummer DDF13 : [" + ergebnis[ 0 ].dok_dat_feld_13 + "]" ); + newDocfield_13 = ergebnis[ 0 ].dok_dat_feld_13; + + // Akte mit Stammdaten und Infos aus der Tabelle "zieltabelle" erstellen + // Registerstruktur unterhalb ebenfalls erstellen + + Document newDoc = d3.archive.newDocument(); + newDoc.type = dokuart_hauptakte; + + newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDoc.editor = "dvelop"; + + newDoc.field[ 1 ] = newDocfield_1; + newDoc.field[ 2 ] = newDocfield_2; + newDoc.field[ 5 ] = newDocfield_5; + newDoc.field[ 10 ] = newDocfield_10; + newDoc.field[ 13 ] = newDocfield_13; + newDoc.field[ 21 ] = newDocfield_21; + newDoc.field[ 22 ] = newDocfield_22; + newDoc.field[ 25 ] = newDocfield_25; + newDoc.field[ 37 ] = newDocfield_37; + newDoc.field[ 42 ] = newDocfield_42; + newDoc.field[ 48 ] = newDocfield_48; + + for ( int i = 0; i < newDocfield_60.size(); i++ ) + { + newDoc.field[ 60 ][ i + 1 ] = newDocfield_60[ i ]; + } + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDoc.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + //Pruefung ob die anzulegende Akte ggf. schon im System angelegt wurde + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_hauptakte + "' and dok_dat_feld_1 = '" + newDocfield_1 + "' AND dok_dat_feld_10 = '" + newDocfield_10 + "'"; + ergebnis = d3.sql.executeAndGet( (String) sqlQuery ); + if ( ergebnis.size() > 0 ) { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: [" + ergebnis[ 0 ].doku_id + "]" ); + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] nicht durchgefuehrt da die Akte bereits existiert, doku_id: " + ergebnis[ 0 ].doku_id, (int) treffer[ i ].id ); + continue; + } + + def aktenanlage_erfolgreich = true; + + if ( debug == 0 ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + fehler( d3, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "] konnte nicht erzeugt werden: " + e.message, (int) treffer[ i ].id ); + aktenanlage_erfolgreich = false; + } + + if ( aktenanlage_erfolgreich ) + { + // sichern der erzeugten Doku-ID + if ( debug == 0 ) + { + sqlQuery = "update " + zieltabelle + " set doku_id = '" + newDoc.id + "' where id = " + treffer[ i ].id; + d3.sql.execute( sqlQuery ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage [" + newDoc.field[ 10 ] + "] erfolgreich, doku_id: [" + newDoc.id + "]" ); + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "] (Debug-Modus eingeschaltet)." ); + } + + + if ( aktenanlage_erfolgreich ) + { + + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakte anlegen + // Dokumentart: Hauptakten-Oberregisterakte, darin alle in den Stammdaten angelegten Oberregister + + sqlQuery = "select distinct dok_dat_feld_2 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "'"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Oberregister-Akte: [" + it.dok_dat_feld_2 + "]" ); + + Document newDocOReg = d3.archive.newDocument(); + + newDocOReg.type = dokuart_oberregisterakte; + + newDocOReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocOReg.editor = "dvelop"; + + newDocOReg.field[ 1 ] = newDocfield_1; + newDocOReg.field[ 2 ] = newDocfield_2; + newDocOReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocOReg.field[ 5 ] = newDocfield_5; + newDocOReg.field[ 10 ] = newDocfield_10; + newDocOReg.field[ 13 ] = newDocfield_13; + newDocOReg.field[ 21 ] = newDocfield_21; + newDocOReg.field[ 25 ] = newDocfield_25; + newDocOReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocOReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocOReg = d3.archive.importDocument( newDocOReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "]" ); + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + newDocOReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "]" ); + } + } + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Weitere Akten werden wegen Fehler nicht angelegt." ); + } + + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": =============================" ); + + if ( aktenanlage_erfolgreich ) + { + ////////////////////////////////////////// + // Ebene unterhalb der Hauptakten-Oberregisterakte anlegen + // Dokumentart: Hauptakten-Registerakte, darin alle in den Stammdaten angelegten Register + + sqlQuery = "select distinct dok_dat_feld_2, dok_dat_feld_3 from firmen_spezifisch where kue_dokuart = 'AVMNT' and dok_dat_feld_1 = '" + aktenschluessel + "' and dok_dat_feld_3 != ''"; + + def resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + + if ( resultRows.size() > 0 ) + { + resultRows.each + { + //xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": erstelle Register-Akte: [" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + + Document newDocReg = d3.archive.newDocument(); + + newDocReg.type = dokuart_registerakte; + + newDocReg.status = Document.DocStatus.DOC_STAT_PROCESSING; + newDocReg.editor = "dvelop"; + + newDocReg.field[ 1 ] = newDocfield_1; + newDocReg.field[ 2 ] = newDocfield_2; + newDocReg.field[ 3 ] = it.dok_dat_feld_2; // Oberregister + newDocReg.field[ 4 ] = it.dok_dat_feld_3; // Register + newDocReg.field[ 5 ] = newDocfield_5; + newDocReg.field[ 10 ] = newDocfield_10; + newDocReg.field[ 13 ] = newDocfield_13; + newDocReg.field[ 21 ] = newDocfield_21; + newDocReg.field[ 25 ] = newDocfield_25; + newDocReg.field[ 42 ] = newDocfield_42; + + for ( int i = 0; i < newDocfield_69.size(); i++ ) + { + newDocReg.field[ 69 ][ i + 1 ] = newDocfield_69[ i ]; + } + + if ( debug == 0 ) + { + try + { + newDocReg = d3.archive.importDocument( newDocReg ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Akte [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] konnte nicht erzeugt werden: " + e.message ); + aktenanlage_erfolgreich = false; + } + } + else + { + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Keine Aktenanlage fuer [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "] (Debug-Modus eingeschaltet)." ); + } + + if ( ( aktenanlage_erfolgreich ) && ( debug == 0 ) ) + { + sqlQuery = "select doku_id from firmen_spezifisch where kue_dokuart = '" + dokuart_oberregisterakte + "' and dok_dat_feld_10 = '" + newDoc.field[ 10 ] + "' and dok_dat_feld_3 = '" + it.dok_dat_feld_2 + "'"; + //xlog( d3, 3, sqlQuery ); + e = d3.sql.executeAndGet( sqlQuery ); + def oregdokuid; + if ( e.size() > 0 ) + { + oregdokuid = e[0].doku_id; + } + xlog( d3, 4, treffer[ i ].ddf10 + " / " + treffer[ i ].id + ": Aktenanlage erfolgreich, doku_id: [" + newDoc.id + "][" + oregdokuid + "][" + newDocReg.id + "] Register: [" + newDoc.field[ 10 ] + "][" + it.dok_dat_feld_2 + "][" + it.dok_dat_feld_3 + "]" ); + } + } + } + } + + } + else + { + fehler( d3, "Es wurde keine passende Sammelakte gefunden. [" + treffer[ i ].ddf10 + "]", (int) treffer[ i ].id ); + } + + xlog( d3, 4, "************************************************" ); + + + } + else + { + // Fehler + fehler( d3, "Mandantennummer in Tabelle und in Aktennummer unterscheiden sich.", (int) treffer[ i ].id ); + } + + + + } + + +} + + + + + + + + + + + + + + + + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + xlog( d3, 2, meldung ); +} + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + zieltabelle + "_3.txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + diff --git a/Kleeberg/migration_nachverknuepfen_0.groovy b/Kleeberg/migration_nachverknuepfen_0.groovy new file mode 100644 index 0000000..4889305 --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_0.groovy @@ -0,0 +1,245 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "0"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "SELECT TOP (200) id, doku_id_father, doku_id_child, fehler FROM " + zieltabelle + " where doku_id_father like '%" + doku_id_ende + "' and fehler is null order by id"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( it.doku_id_father, it.doku_id_child, "Master", false, false ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + " / ID " + it.id + ": (C) [" + it.doku_id_child + "] => (F) [" + it.doku_id_father + "] => " + meldung ); + + if ( debug == 0 ) + { + fehler( d3, meldung, (int) it.id ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + //xlog( d3, 2, meldung ); +} + + + + + diff --git a/Kleeberg/migration_nachverknuepfen_1.groovy b/Kleeberg/migration_nachverknuepfen_1.groovy new file mode 100644 index 0000000..fee4082 --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_1.groovy @@ -0,0 +1,245 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "1"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "SELECT TOP (200) id, doku_id_father, doku_id_child, fehler FROM " + zieltabelle + " where doku_id_father like '%" + doku_id_ende + "' and fehler is null order by id"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( it.doku_id_father, it.doku_id_child, "Master", false, false ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + " / ID " + it.id + ": (C) [" + it.doku_id_child + "] => (F) [" + it.doku_id_father + "] => " + meldung ); + + if ( debug == 0 ) + { + fehler( d3, meldung, (int) it.id ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + //xlog( d3, 2, meldung ); +} + + + + + diff --git a/Kleeberg/migration_nachverknuepfen_2.groovy b/Kleeberg/migration_nachverknuepfen_2.groovy new file mode 100644 index 0000000..6e6f714 --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_2.groovy @@ -0,0 +1,245 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "2"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "SELECT TOP (200) id, doku_id_father, doku_id_child, fehler FROM " + zieltabelle + " where doku_id_father like '%" + doku_id_ende + "' and fehler is null order by id"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( it.doku_id_father, it.doku_id_child, "Master", false, false ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + " / ID " + it.id + ": (C) [" + it.doku_id_child + "] => (F) [" + it.doku_id_father + "] => " + meldung ); + + if ( debug == 0 ) + { + fehler( d3, meldung, (int) it.id ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + //xlog( d3, 2, meldung ); +} + + + + + diff --git a/Kleeberg/migration_nachverknuepfen_3.groovy b/Kleeberg/migration_nachverknuepfen_3.groovy new file mode 100644 index 0000000..5715cae --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_3.groovy @@ -0,0 +1,245 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "3"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "SELECT TOP (200) id, doku_id_father, doku_id_child, fehler FROM " + zieltabelle + " where doku_id_father like '%" + doku_id_ende + "' and fehler is null order by id"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( it.doku_id_father, it.doku_id_child, "Master", false, false ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + " / ID " + it.id + ": (C) [" + it.doku_id_child + "] => (F) [" + it.doku_id_father + "] => " + meldung ); + + if ( debug == 0 ) + { + fehler( d3, meldung, (int) it.id ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + //xlog( d3, 2, meldung ); +} + + + + + diff --git a/Kleeberg/migration_nachverknuepfen_4.groovy b/Kleeberg/migration_nachverknuepfen_4.groovy new file mode 100644 index 0000000..40060f2 --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_4.groovy @@ -0,0 +1,244 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "4"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "SELECT TOP (200) id, doku_id_father, doku_id_child, fehler FROM " + zieltabelle + " where doku_id_father like '%" + doku_id_ende + "' and fehler is null order by id"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( it.doku_id_father, it.doku_id_child, "Master", false, false ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + " / ID " + it.id + ": (C) [" + it.doku_id_child + "] => (F) [" + it.doku_id_father + "] => " + meldung ); + + if ( debug == 0 ) + { + fehler( d3, meldung, (int) it.id ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + //xlog( d3, 2, meldung ); +} + + + + + diff --git a/Kleeberg/migration_nachverknuepfen_5.groovy b/Kleeberg/migration_nachverknuepfen_5.groovy new file mode 100644 index 0000000..214a01d --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_5.groovy @@ -0,0 +1,243 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "5"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "SELECT TOP (200) id, doku_id_father, doku_id_child, fehler FROM " + zieltabelle + " where doku_id_father like '%" + doku_id_ende + "' and fehler is null order by id"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( it.doku_id_father, it.doku_id_child, "Master", false, false ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + " / ID " + it.id + ": (C) [" + it.doku_id_child + "] => (F) [" + it.doku_id_father + "] => " + meldung ); + + if ( debug == 0 ) + { + fehler( d3, meldung, (int) it.id ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + //xlog( d3, 2, meldung ); +} + + + + + diff --git a/Kleeberg/migration_nachverknuepfen_6.groovy b/Kleeberg/migration_nachverknuepfen_6.groovy new file mode 100644 index 0000000..fda2b32 --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_6.groovy @@ -0,0 +1,245 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "6"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "SELECT TOP (200) id, doku_id_father, doku_id_child, fehler FROM " + zieltabelle + " where doku_id_father like '%" + doku_id_ende + "' and fehler is null order by id"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( it.doku_id_father, it.doku_id_child, "Master", false, false ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + " / ID " + it.id + ": (C) [" + it.doku_id_child + "] => (F) [" + it.doku_id_father + "] => " + meldung ); + + if ( debug == 0 ) + { + fehler( d3, meldung, (int) it.id ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + //xlog( d3, 2, meldung ); +} + + + + + diff --git a/Kleeberg/migration_nachverknuepfen_7.groovy b/Kleeberg/migration_nachverknuepfen_7.groovy new file mode 100644 index 0000000..7b942ee --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_7.groovy @@ -0,0 +1,245 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "7"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "SELECT TOP (200) id, doku_id_father, doku_id_child, fehler FROM " + zieltabelle + " where doku_id_father like '%" + doku_id_ende + "' and fehler is null order by id"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( it.doku_id_father, it.doku_id_child, "Master", false, false ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + " / ID " + it.id + ": (C) [" + it.doku_id_child + "] => (F) [" + it.doku_id_father + "] => " + meldung ); + + if ( debug == 0 ) + { + fehler( d3, meldung, (int) it.id ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + //xlog( d3, 2, meldung ); +} + + + + + diff --git a/Kleeberg/migration_nachverknuepfen_8.groovy b/Kleeberg/migration_nachverknuepfen_8.groovy new file mode 100644 index 0000000..8c6682d --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_8.groovy @@ -0,0 +1,245 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "8"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "SELECT TOP (200) id, doku_id_father, doku_id_child, fehler FROM " + zieltabelle + " where doku_id_father like '%" + doku_id_ende + "' and fehler is null order by id"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( it.doku_id_father, it.doku_id_child, "Master", false, false ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + " / ID " + it.id + ": (C) [" + it.doku_id_child + "] => (F) [" + it.doku_id_father + "] => " + meldung ); + + if ( debug == 0 ) + { + fehler( d3, meldung, (int) it.id ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + //xlog( d3, 2, meldung ); +} + + + + + diff --git a/Kleeberg/migration_nachverknuepfen_9.groovy b/Kleeberg/migration_nachverknuepfen_9.groovy new file mode 100644 index 0000000..26cdce9 --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_9.groovy @@ -0,0 +1,245 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "9"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "SELECT TOP (200) id, doku_id_father, doku_id_child, fehler FROM " + zieltabelle + " where doku_id_father like '%" + doku_id_ende + "' and fehler is null order by id"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( it.doku_id_father, it.doku_id_child, "Master", false, false ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + " / ID " + it.id + ": (C) [" + it.doku_id_child + "] => (F) [" + it.doku_id_father + "] => " + meldung ); + + if ( debug == 0 ) + { + fehler( d3, meldung, (int) it.id ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + +def fehler( D3Interface d3, String meldung, int id ) +{ + def meldung_db; + + if ( meldung.length() > 250 ) + { + meldung_db = meldung.substring( 0, 249 ); + } + else + { + meldung_db = meldung; + } + + if ( debug == 0 ) + { + sql = "update " + zieltabelle + " set fehler = '" + meldung_db + "' where id = " + id; + d3.sql.execute( sql ); + } + + //xlog( d3, 2, meldung ); +} + + + + + diff --git a/Kleeberg/migration_nachverknuepfen_BP.groovy b/Kleeberg/migration_nachverknuepfen_BP.groovy new file mode 100644 index 0000000..3138156 --- /dev/null +++ b/Kleeberg/migration_nachverknuepfen_BP.groovy @@ -0,0 +1,223 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_nachverknuepfen_BP.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + +@Field zieltabelle = "mig_multi_link_work"; + + +@Field doku_id_ende = "0"; + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* zieltabelle : " + zieltabelle ); +xlog( d3, 4, "* doku_id_ende : " + doku_id_ende ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + + +def sqlQuery = "select top (150) doku_id from firmen_spezifisch where kue_dokuart = 'DBETR' and doku_id not in ( select doku_id_unter from dokumenten_verknuepf )"; + +xlog( d3, 5, sqlQuery ); + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); +def meldung, ergebnis, xdebug; + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + + +if ( resultRows.size() > 0 ) +{ + def i = 0; + + resultRows.each + { + i++; + if ( debug == 0 ) + { + ergebnis = d3.call.link_documents( "", it.doku_id, "Master", false, true ); + } + else + { + ergebnis = 0 + } + + + + if ( ergebnis == 0 ) + { + xdebug = ""; + + if ( debug != 0 ) + { + xdebug = " (DEBUG)"; + } + + meldung = "OK" + xdebug; + } + else + { + meldung = "Fehler: RC [" + ergebnis + "]"; + } + + xlog( d3, 4, "Nr. " + i + ": (C) [" + it.doku_id + "] => " + meldung ); + + if ( debug == 0 ) + { + xlog( d3, 4, meldung ); + } + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + "_" + doku_id_ende + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} + + + + + + + + + + diff --git a/Kleeberg/migration_notizen.groovy b/Kleeberg/migration_notizen.groovy new file mode 100644 index 0000000..385fcea --- /dev/null +++ b/Kleeberg/migration_notizen.groovy @@ -0,0 +1,217 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_mandant_notizen.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + +def i, ergebniszeilen, ergebnistext; + +def sqlQuery = "select top (100) id,ddf1,notiz from mig_mandant_notizen where fehler is null and status is null "; + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + +if ( resultRows.size() > 0 ) +{ + xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); + xlog( d3, 4, "************************************************" ); + + for ( i = 0; i < resultRows.size(); i++ ) + { + + ergebniszeilen = d3.sql.executeAndGet( "select doku_id from firmen_spezifisch where kue_dokuart = 'AMAND' and dok_dat_feld_1 = '" + resultRows[ i ].ddf1 + "' " ); + + if ( ergebniszeilen.size() > 0 ) + { + ergebnistext = "ID " + resultRows[ i ].id + " / Mandantnummer [" + resultRows[ i ].ddf1 + "] Mandantenakte Doku-ID: [" + ergebniszeilen[ 0 ].doku_id + "] "; + + if ( debug == 0 ) + { + //def ergebnis = d3.call.note_add_string( resultRows[ i ].notiz, ergebniszeilen[ 0 ].doku_id, "Master" ); // hat eine Begrenzung auf die Länge der Notiz (1997 Zeichen sind noch erlaubt). + + def nodeFile = new File( "d:\\d3\\apps\\notiz.txt" ); + + nodeFile.append( resultRows[ i ].notiz ); + + def ergebnis = d3.call.note_add_file( "d:\\d3\\apps\\notiz.txt", ergebniszeilen[ 0 ].doku_id, "Master" ); + + nodeFile.delete(); + + if ( ergebnis == 0 ) + { + ergebnistext = ergebnistext + "Die Notiz (ID " + resultRows[ i ].id + ", Laenge: " + resultRows[ i ].notiz.length() + " Zeichen) wurde erfolgreich angelegt." + d3.sql.execute( "update mig_mandant_notizen set status = '0' where id = " + resultRows[ i ].id ); + } + else + { + ergebnistext = ergebnistext + "Die Notiz (ID " + resultRows[ i ].id + ", Laenge: " + resultRows[ i ].notiz.length() + " Zeichen) konnte nicht angelegt werden: RC " + ergebnis; + d3.sql.execute( "update mig_mandant_notizen set status = '" + ergebnis + "', fehler = '" + ergebnistext + "' where id = " + resultRows[ i ].id ); + } + + xlog( d3, 4, ergebnistext ); + } + else + { + xlog( d3, 3, ergebnistext + "DEBUG ist eingeschaltet, es werden keine Aenderungen durchgefuehrt." ); + } + + } + else + { + xlog( d3, 3, "ID " + resultRows[ i ].id + " / Mandantnummer [" + resultRows[ i ].ddf1 + "]: Es wurde keine Mandantakte gefunden." ); + } + } + + +} +else +{ + xlog( d3, 3, "Es wurden keine passenden Treffer gefunden!" ); +} + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} \ No newline at end of file diff --git a/Kleeberg/migration_notizen_hauptakten.groovy b/Kleeberg/migration_notizen_hauptakten.groovy new file mode 100644 index 0000000..df567b0 --- /dev/null +++ b/Kleeberg/migration_notizen_hauptakten.groovy @@ -0,0 +1,218 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_notizen_hauptakten.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + +///////////////////////////////////////////////////////////////////////// + +// In welcher Tabelle soll nach den zu erstellenden Notizen gesucht werden? +@Field zieltabelle = "mig_hauptakten_notizen"; + + + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + +def i, ergebniszeilen, ergebnistext; + +def sqlQuery = "select top (100) id,ddf10,notiz from " + zieltabelle + " where fehler is null and status is null and ddf10 like '%ST%' "; + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + +if ( resultRows.size() > 0 ) +{ + xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); + xlog( d3, 4, "************************************************" ); + + for ( i = 0; i < resultRows.size(); i++ ) + { + + ergebniszeilen = d3.sql.executeAndGet( "select doku_id from firmen_spezifisch where kue_dokuart = 'ASTEU' and dok_dat_feld_10 = '" + resultRows[ i ].ddf10 + "' " ); + + if ( ergebniszeilen.size() > 0 ) + { + ergebnistext = "ID " + resultRows[ i ].id + " / Aktennummer [" + resultRows[ i ].ddf10 + "] Hauptakte Doku-ID: [" + ergebniszeilen[ 0 ].doku_id + "] "; + + if ( debug == 0 ) + { + //def ergebnis = d3.call.note_add_string( resultRows[ i ].notiz, ergebniszeilen[ 0 ].doku_id, "Master" ); // hat eine Begrenzung auf die Länge der Notiz (1997 Zeichen sind noch erlaubt). + + def nodeFile = new File( "d:\\d3\\apps\\notiz_hauptakte.txt" ); + + nodeFile.append( resultRows[ i ].notiz ); + + def ergebnis = d3.call.note_add_file( "d:\\d3\\apps\\notiz_hauptakte.txt", ergebniszeilen[ 0 ].doku_id, "Master" ); + + nodeFile.delete(); + + if ( ergebnis == 0 ) + { + ergebnistext = ergebnistext + "Die Notiz (ID " + resultRows[ i ].id + ", Laenge: " + resultRows[ i ].notiz.length() + " Zeichen) wurde erfolgreich angelegt." + d3.sql.execute( "update " + zieltabelle + " set status = '0' where id = " + resultRows[ i ].id ); + } + else + { + ergebnistext = ergebnistext + "Die Notiz (ID " + resultRows[ i ].id + ", Laenge: " + resultRows[ i ].notiz.length() + " Zeichen) konnte nicht angelegt werden: RC " + ergebnis; + d3.sql.execute( "update " + zieltabelle + " set status = '" + ergebnis + "', fehler = '" + ergebnistext + "' where id = " + resultRows[ i ].id ); + } + + xlog( d3, 4, ergebnistext ); + } + else + { + xlog( d3, 3, ergebnistext + "DEBUG ist eingeschaltet, es werden keine Aenderungen durchgefuehrt." ); + } + + } + else + { + xlog( d3, 3, "ID " + resultRows[ i ].id + " / Aktennummer [" + resultRows[ i ].ddf10 + "]: Es wurde keine Hauptakte gefunden." ); + } + } + + +} +else +{ + xlog( d3, 3, "Es wurden keine passenden Treffer gefunden!" ); +} + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} \ No newline at end of file diff --git a/Kleeberg/migration_verknuepfungen_1.groovy b/Kleeberg/migration_verknuepfungen_1.groovy new file mode 100644 index 0000000..71fc3e6 --- /dev/null +++ b/Kleeberg/migration_verknuepfungen_1.groovy @@ -0,0 +1,566 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_verknuepfungen_1.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + +def sqlQuery = "select top (100) id,unique_id_doc,unique_id_fol,ddf10,ddf3,ddf4,ddf23,ddf17,ddf32 from mig_link_docs_2 where doku_id_target_fol is null and ddf3 is not null and ddf10 like '%DA%' and fehler is null and id < 177869 "; + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( resultRows.size() > 0 ) +{ + for( int i = 0 ; i <= resultRows.size() - 1 ; i++ ) + { + def dummy_ddf3, dummy_ddf4, dummy_ddf23, dummy_ddf17, dummy_ddf32; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": pruefen, ob folgende Aktenstruktur existiert:" ); + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Unique-ID Dokument : [" + resultRows[ i ].unique_id_doc + "]" ); + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF10 / Aktennummer : [" + resultRows[ i ].ddf10 + "]" ); + + if ( ( ! resultRows[ i ].ddf3 ) || ( resultRows[ i ].ddf3 == "null" ) ) + { + dummy_ddf3 = ""; + } + else + { + dummy_ddf3 = resultRows[ i ].ddf3; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF03 / Oberregister : [" + dummy_ddf3 + "]" ); + + if ( ( ! resultRows[ i ].ddf4 ) || ( resultRows[ i ].ddf4 == "null" ) ) + { + dummy_ddf4 = ""; + } + else + { + dummy_ddf4 = resultRows[ i ].ddf4; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF04 / Register : [" + dummy_ddf4 + "]" ); + + if ( ( ! resultRows[ i ].ddf23 ) || ( resultRows[ i ].ddf23 == "null" ) ) + { + dummy_ddf23 = ""; + } + else + { + dummy_ddf23 = resultRows[ i ].ddf23; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF23 / Unterregister : [" + dummy_ddf23 + "]" ); + + if ( ( ! resultRows[ i ].ddf17 ) || ( resultRows[ i ].ddf17 == "null" ) ) + { + dummy_ddf17 = ""; + } + else + { + dummy_ddf17 = resultRows[ i ].ddf17; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF17 / 2. Unterregister : [" + dummy_ddf17 + "]" ); + + if ( ( ! resultRows[ i ].ddf32 ) || ( resultRows[ i ].ddf32 == "null" ) ) + { + dummy_ddf32 = ""; + } + else + { + dummy_ddf32 = resultRows[ i ].ddf32; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF32 / 3. Unterregister : [" + dummy_ddf32 + "]" ); + + def typ = resultRows[ i ].ddf10.substring(5, 7); + + xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": erkannter Typ: " + typ ); + + def orakte, rakte, urakte, urakte2, urakte3; + + + switch ( typ ) + { + case "FI": + akte = "AFIBA"; + orakte = "AFIOR"; + rakte = "AFIRA"; + urakte = "AFIUR"; + urakte2 = "AFIU2"; + urakte3 = ""; + break; + case "DA": + akte = "ADAUR"; + orakte = "AOREG"; + rakte = "AREGS"; + urakte = "AUREG"; + urakte2 = "AURG2"; + urakte3 = "AURG3"; + break; + case "ST": + akte = "ASTEU"; + orakte = "ASTOR"; + rakte = "ASTRA"; + urakte = "ASTUR"; + urakte2 = "ASTU2"; + urakte3 = ""; + break; + case "BE": + akte = "ABERB"; + orakte = "ABERO"; + rakte = "ABERA"; + urakte = "ABEUR"; + urakte2 = "ABEU2"; + urakte3 = ""; + break; + case "BP": + akte = "ABETR"; + orakte = "ABEOR"; + rakte = "ABEPA"; + urakte = "ABPUR"; + urakte2 = "ABPU2"; + urakte3 = ""; + break; + case "LO": + akte = "ALOJA"; + orakte = "ALBOR"; + rakte = "ALBRE"; + urakte = "ALJUR"; + urakte2 = "ALJR2"; + urakte3 = ""; + break; + case "LS": + akte = "ALBSA"; + orakte = "ALBSO"; + rakte = "ALORE"; + urakte = "ALOUR"; + urakte2 = "ALBU2"; + urakte3 = ""; + break; + case "JA": + akte = "AJAAA"; + orakte = "AJAOB"; + rakte = "AJAAB"; + urakte = "AJAUR"; + urakte2 = "AJAU2"; + urakte3 = ""; + break; + case "RE": + akte = "AAURE"; + orakte = "AAURR"; + rakte = "AAURA"; + urakte = "AAURU"; + urakte2 = "AAUR2"; + urakte3 = ""; + break; + } + + + + + def schritt_1 = [ "kue_dokuart": orakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3 ]; + def schritt_2 = [ "kue_dokuart": rakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4 ]; + def schritt_3 = [ "kue_dokuart": urakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23 ]; + def schritt_4 = [ "kue_dokuart": urakte2, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23, "dok_dat_feld_17": dummy_ddf17 ]; + def schritt_5 = [ "kue_dokuart": urakte3, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23, "dok_dat_feld_17": dummy_ddf17, "dok_dat_feld_32": dummy_ddf32 ]; + + def schritte = [ schritt_1, schritt_2, schritt_3, schritt_4, schritt_5 ]; + + def gemerkte_doku_id; + def lege_akte_an; + + for ( int m = 0; m <= schritte.size() - 1 ; m++ ) + { + + // Zusammenbauen des Such-Statements: + + def STATEMENT = "select doku_id from firmen_spezifisch where "; + def log = "Suche nach folgenden Kriterien : "; + def x = 0; + def und; + def kein_problem = true; + lege_akte_an = true; + + schritte[ m ].each { eintrag -> + + //xlog( d3, 3, "Key [" + eintrag.key + "] Value [" + eintrag.value + "]" ); + if ( x > 0 ) + { + und = " and "; + } + else + { + und = ""; + x = 1; + } + + if ( ( eintrag.value == "" ) || ( eintrag.value == null ) ) + { + kein_problem = false; + } + + if ( ( eintrag.key == "kue_dokuart" ) && ( eintrag.value == "" ) ) + { + kein_problem = false; + } + + STATEMENT = STATEMENT + und + eintrag.key + " = '" + eintrag.value + "' "; + log = log + "[" + eintrag.key + "] => [" + eintrag.value + "] "; + } + + if ( kein_problem ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + log ); + + xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + STATEMENT ); + + def ergebnis = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( ergebnis.size() > 0 ) + { + // Akte existiert + // Doku-ID merken: + gemerkte_doku_id = ergebnis[ 0 ].doku_id; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert, gemerkte Doku-ID: [" + gemerkte_doku_id + "]" ); + + //def updatesql = "update mig_verknuepfung set ziel_dok = '" + ergebnis[ 0 ].doku_id + "' where id = " + resultRows[ i ].id; + + } + else + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert nicht, muss angelegt werden." ); + + + // Akte existiert nicht, muss angelegt werden: + Document newDoc = d3.archive.newDocument(); + //xlog( d3, 2, "Schritte kue_dokuart = [" + schritte[ m ] + "]"); + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze Dokumentart [" + schritte[ m ].kue_dokuart + "]" ); + + newDoc.type = schritte[ m ].kue_dokuart; + + + + newDoc.status = Document.DocStatus.DOC_STAT_RELEASE; + //newDoc.editor = "dvelop"; + + // Mit diesem Statement wird versucht, die Hauptakte zu finden, um von dieser dann Eigenschaftswerte zu lesen. Kann diese Akte nicht gefunden werden, ist das ein Fehlerzustand, + // der am Datensatz in der Quelle festgehalten wird. + STATEMENT = "select doku_id, dok_dat_feld_25, dok_dat_feld_42, dok_dat_feld_21, dok_dat_feld_2, dok_dat_feld_13, dok_dat_feld_37, dok_dat_feld_1 from firmen_spezifisch where kue_dokuart = '" + akte + "' and dok_dat_feld_10 = '" + resultRows[ i ].ddf10 + "'"; + + def erg = d3.sql.executeAndGet( (String) STATEMENT ); + //xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + STATEMENT ); + + if ( schritte[ m ].dok_dat_feld_1 ) // Mandantnummer + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF1 / Mandantnummer [" + schritte[ m ].dok_dat_feld_1 + "]" ); + newDoc.field[ 1 ] = schritte[ m ].dok_dat_feld_1; + } + + + if ( erg.size() > 0 ) + { + if ( ( erg[ 0 ].dok_dat_feld_1 ) && ( ! schritte[ m ].dok_dat_feld_1 ) ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF1 / Mandantnummer [" + erg[ 0 ].dok_dat_feld_1 + "]" ); + newDoc.field[ 1 ] = erg[ 0 ].dok_dat_feld_1; + } + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF10 / Aktennummer [" + resultRows[ i ].ddf10 + "]" ); + newDoc.field[ 10 ] = resultRows[ i ].ddf10; + + if ( erg[ 0 ].dok_dat_feld_25 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF25 / Geschaeftsfuehrer [" + erg[ 0 ].dok_dat_feld_25 + "]" ); + newDoc.field[ 25 ] = erg[ 0 ].dok_dat_feld_25; + } + + if ( erg[ 0 ].dok_dat_feld_42 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF42 / Briefkopf [" + erg[ 0 ].dok_dat_feld_42 + "]" ); + newDoc.field[ 42 ] = erg[ 0 ].dok_dat_feld_42; + } + + if ( erg[ 0 ].dok_dat_feld_21 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF21 / Aktenname [" + erg[ 0 ].dok_dat_feld_21 + "]" ); + newDoc.field[ 21 ] = erg[ 0 ].dok_dat_feld_21; + } + + if ( erg[ 0 ].dok_dat_feld_2 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF2 / Mandantname [" + erg[ 0 ].dok_dat_feld_2 + "]" ); + newDoc.field[ 2 ] = erg[ 0 ].dok_dat_feld_2; + } + + if ( erg[ 0 ].dok_dat_feld_13 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF13 / Mandantgruppennummer [" + erg[ 0 ].dok_dat_feld_13 + "]" ); + newDoc.field[ 13 ] = erg[ 0 ].dok_dat_feld_13; + } + + if ( erg[ 0 ].dok_dat_feld_37 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF37 / Mandatsverantwortlicher [" + erg[ 0 ].dok_dat_feld_37 + "]" ); + newDoc.field[ 37 ] = erg[ 0 ].dok_dat_feld_37; + } + + } + else + { + lege_akte_an = false; + } + + + if ( schritte[ m ].dok_dat_feld_3 ) // Oberregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF3 / Oberregister [" + schritte[ m ].dok_dat_feld_3 + "]" ); + newDoc.field[ 3 ] = schritte[ m ].dok_dat_feld_3; + } + + if ( schritte[ m ].dok_dat_feld_4 ) // Register + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF4 / Register [" + schritte[ m ].dok_dat_feld_4 + "]" ); + newDoc.field[ 4 ] = schritte[ m ].dok_dat_feld_4; + } + + if ( schritte[ m ].dok_dat_feld_23 ) // Unterregister + { + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF23 / Unterregister [" + schritte[ m ].dok_dat_feld_23 + "]" ); + newDoc.field[ 23 ] = schritte[ m ].dok_dat_feld_23; + } + + if ( schritte[ m ].dok_dat_feld_17 ) // 2. Unterregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF17 / 2. Unterregister [" + schritte[ m ].dok_dat_feld_17 + "]" ); + newDoc.field[ 17 ] = schritte[ m ].dok_dat_feld_17; + } + + if ( schritte[ m ].dok_dat_feld_32 ) // 3. Unterregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF32 / 3. Unterregister [" + schritte[ m ].dok_dat_feld_32 + "]" ); + newDoc.field[ 32 ] = schritte[ m ].dok_dat_feld_32; + } + + def fehler = false; + + if ( debug == 0 ) + { + if ( lege_akte_an ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte konnte nicht erzeugt werden: " + e.message ); + fehler = true; + } + + if ( ! fehler ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Doku-ID der erzeugten Akte : [" + newDoc.id + "]" ); + gemerkte_doku_id = newDoc.id; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert, gemerkte Doku-ID: [" + gemerkte_doku_id + "]" ); + } + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Hauptakte wurde nicht gefunden => Akte wurde nicht erzeugt." ); + break; + } + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte wurde nicht erzeugt / Debug-Modus eingeschaltet." ); + } + } + + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ":****************************" ); + + } + } + + + if ( gemerkte_doku_id ) + { + + def USTATEMENT = "update mig_link_docs_2 set doku_id_target_fol = '" + gemerkte_doku_id + "' where id = '" + resultRows[ i ].id + "'"; + if ( debug == 0 ) + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": setze gemerkte Doku-ID [" + gemerkte_doku_id + "] fuer ID " + resultRows[ i ].id ); + d3.sql.executeAndGet( (String) USTATEMENT ); + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Debug-Modus eingeschaltet, [" + gemerkte_doku_id + "] fuer ID " + resultRows[ i ].id + " wurde nicht gesetzt."); + } + } + + if ( ! lege_akte_an ) + { + def USTATEMENT = "update mig_link_docs_2 set fehler = 'Die Hauptakte existiert nicht.' where id = '" + resultRows[ i ].id + "'"; + if ( debug == 0 ) + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": setze Fehler 'Die Hauptakte existiert nicht.' fuer ID " + resultRows[ i ].id ); + d3.sql.executeAndGet( (String) USTATEMENT ); + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Debug-Modus eingeschaltet, Fehler 'Die Hauptakte existiert nicht.' fuer ID " + resultRows[ i ].id + " wurde nicht gesetzt."); + } + } + + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ":*******************************************************" ); + } + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} \ No newline at end of file diff --git a/Kleeberg/migration_verknuepfungen_2.groovy b/Kleeberg/migration_verknuepfungen_2.groovy new file mode 100644 index 0000000..4a8149c --- /dev/null +++ b/Kleeberg/migration_verknuepfungen_2.groovy @@ -0,0 +1,566 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_verknuepfungen_2.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + +def sqlQuery = "select top (100) id,unique_id_doc,unique_id_fol,ddf10,ddf3,ddf4,ddf23,ddf17,ddf32 from mig_link_docs_2 where doku_id_target_fol is null and ddf3 is not null and ddf10 like '%DA%' and fehler is null and id >= 177869 and id < 613985 "; + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( resultRows.size() > 0 ) +{ + for( int i = 0 ; i <= resultRows.size() - 1 ; i++ ) + { + def dummy_ddf3, dummy_ddf4, dummy_ddf23, dummy_ddf17, dummy_ddf32; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": pruefen, ob folgende Aktenstruktur existiert:" ); + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Unique-ID Dokument : [" + resultRows[ i ].unique_id_doc + "]" ); + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF10 / Aktennummer : [" + resultRows[ i ].ddf10 + "]" ); + + if ( ( ! resultRows[ i ].ddf3 ) || ( resultRows[ i ].ddf3 == "null" ) ) + { + dummy_ddf3 = ""; + } + else + { + dummy_ddf3 = resultRows[ i ].ddf3; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF03 / Oberregister : [" + dummy_ddf3 + "]" ); + + if ( ( ! resultRows[ i ].ddf4 ) || ( resultRows[ i ].ddf4 == "null" ) ) + { + dummy_ddf4 = ""; + } + else + { + dummy_ddf4 = resultRows[ i ].ddf4; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF04 / Register : [" + dummy_ddf4 + "]" ); + + if ( ( ! resultRows[ i ].ddf23 ) || ( resultRows[ i ].ddf23 == "null" ) ) + { + dummy_ddf23 = ""; + } + else + { + dummy_ddf23 = resultRows[ i ].ddf23; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF23 / Unterregister : [" + dummy_ddf23 + "]" ); + + if ( ( ! resultRows[ i ].ddf17 ) || ( resultRows[ i ].ddf17 == "null" ) ) + { + dummy_ddf17 = ""; + } + else + { + dummy_ddf17 = resultRows[ i ].ddf17; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF17 / 2. Unterregister : [" + dummy_ddf17 + "]" ); + + if ( ( ! resultRows[ i ].ddf32 ) || ( resultRows[ i ].ddf32 == "null" ) ) + { + dummy_ddf32 = ""; + } + else + { + dummy_ddf32 = resultRows[ i ].ddf32; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF32 / 3. Unterregister : [" + dummy_ddf32 + "]" ); + + def typ = resultRows[ i ].ddf10.substring(5, 7); + + xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": erkannter Typ: " + typ ); + + def orakte, rakte, urakte, urakte2, urakte3; + + + switch ( typ ) + { + case "FI": + akte = "AFIBA"; + orakte = "AFIOR"; + rakte = "AFIRA"; + urakte = "AFIUR"; + urakte2 = "AFIU2"; + urakte3 = ""; + break; + case "DA": + akte = "ADAUR"; + orakte = "AOREG"; + rakte = "AREGS"; + urakte = "AUREG"; + urakte2 = "AURG2"; + urakte3 = "AURG3"; + break; + case "ST": + akte = "ASTEU"; + orakte = "ASTOR"; + rakte = "ASTRA"; + urakte = "ASTUR"; + urakte2 = "ASTU2"; + urakte3 = ""; + break; + case "BE": + akte = "ABERB"; + orakte = "ABERO"; + rakte = "ABERA"; + urakte = "ABEUR"; + urakte2 = "ABEU2"; + urakte3 = ""; + break; + case "BP": + akte = "ABETR"; + orakte = "ABEOR"; + rakte = "ABEPA"; + urakte = "ABPUR"; + urakte2 = "ABPU2"; + urakte3 = ""; + break; + case "LO": + akte = "ALOJA"; + orakte = "ALBOR"; + rakte = "ALBRE"; + urakte = "ALJUR"; + urakte2 = "ALJR2"; + urakte3 = ""; + break; + case "LS": + akte = "ALBSA"; + orakte = "ALBSO"; + rakte = "ALORE"; + urakte = "ALOUR"; + urakte2 = "ALBU2"; + urakte3 = ""; + break; + case "JA": + akte = "AJAAA"; + orakte = "AJAOB"; + rakte = "AJAAB"; + urakte = "AJAUR"; + urakte2 = "AJAU2"; + urakte3 = ""; + break; + case "RE": + akte = "AAURE"; + orakte = "AAURR"; + rakte = "AAURA"; + urakte = "AAURU"; + urakte2 = "AAUR2"; + urakte3 = ""; + break; + } + + + + + def schritt_1 = [ "kue_dokuart": orakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3 ]; + def schritt_2 = [ "kue_dokuart": rakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4 ]; + def schritt_3 = [ "kue_dokuart": urakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23 ]; + def schritt_4 = [ "kue_dokuart": urakte2, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23, "dok_dat_feld_17": dummy_ddf17 ]; + def schritt_5 = [ "kue_dokuart": urakte3, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23, "dok_dat_feld_17": dummy_ddf17, "dok_dat_feld_32": dummy_ddf32 ]; + + def schritte = [ schritt_1, schritt_2, schritt_3, schritt_4, schritt_5 ]; + + def gemerkte_doku_id; + def lege_akte_an; + + for ( int m = 0; m <= schritte.size() - 1 ; m++ ) + { + + // Zusammenbauen des Such-Statements: + + def STATEMENT = "select doku_id from firmen_spezifisch where "; + def log = "Suche nach folgenden Kriterien : "; + def x = 0; + def und; + def kein_problem = true; + lege_akte_an = true; + + schritte[ m ].each { eintrag -> + + //xlog( d3, 3, "Key [" + eintrag.key + "] Value [" + eintrag.value + "]" ); + if ( x > 0 ) + { + und = " and "; + } + else + { + und = ""; + x = 1; + } + + if ( ( eintrag.value == "" ) || ( eintrag.value == null ) ) + { + kein_problem = false; + } + + if ( ( eintrag.key == "kue_dokuart" ) && ( eintrag.value == "" ) ) + { + kein_problem = false; + } + + STATEMENT = STATEMENT + und + eintrag.key + " = '" + eintrag.value + "' "; + log = log + "[" + eintrag.key + "] => [" + eintrag.value + "] "; + } + + if ( kein_problem ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + log ); + + xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + STATEMENT ); + + def ergebnis = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( ergebnis.size() > 0 ) + { + // Akte existiert + // Doku-ID merken: + gemerkte_doku_id = ergebnis[ 0 ].doku_id; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert, gemerkte Doku-ID: [" + gemerkte_doku_id + "]" ); + + //def updatesql = "update mig_verknuepfung set ziel_dok = '" + ergebnis[ 0 ].doku_id + "' where id = " + resultRows[ i ].id; + + } + else + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert nicht, muss angelegt werden." ); + + + // Akte existiert nicht, muss angelegt werden: + Document newDoc = d3.archive.newDocument(); + //xlog( d3, 2, "Schritte kue_dokuart = [" + schritte[ m ] + "]"); + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze Dokumentart [" + schritte[ m ].kue_dokuart + "]" ); + + newDoc.type = schritte[ m ].kue_dokuart; + + + + newDoc.status = Document.DocStatus.DOC_STAT_RELEASE; + //newDoc.editor = "dvelop"; + + // Mit diesem Statement wird versucht, die Hauptakte zu finden, um von dieser dann Eigenschaftswerte zu lesen. Kann diese Akte nicht gefunden werden, ist das ein Fehlerzustand, + // der am Datensatz in der Quelle festgehalten wird. + STATEMENT = "select doku_id, dok_dat_feld_25, dok_dat_feld_42, dok_dat_feld_21, dok_dat_feld_2, dok_dat_feld_13, dok_dat_feld_37, dok_dat_feld_1 from firmen_spezifisch where kue_dokuart = '" + akte + "' and dok_dat_feld_10 = '" + resultRows[ i ].ddf10 + "'"; + + def erg = d3.sql.executeAndGet( (String) STATEMENT ); + //xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + STATEMENT ); + + if ( schritte[ m ].dok_dat_feld_1 ) // Mandantnummer + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF1 / Mandantnummer [" + schritte[ m ].dok_dat_feld_1 + "]" ); + newDoc.field[ 1 ] = schritte[ m ].dok_dat_feld_1; + } + + + if ( erg.size() > 0 ) + { + if ( ( erg[ 0 ].dok_dat_feld_1 ) && ( ! schritte[ m ].dok_dat_feld_1 ) ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF1 / Mandantnummer [" + erg[ 0 ].dok_dat_feld_1 + "]" ); + newDoc.field[ 1 ] = erg[ 0 ].dok_dat_feld_1; + } + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF10 / Aktennummer [" + resultRows[ i ].ddf10 + "]" ); + newDoc.field[ 10 ] = resultRows[ i ].ddf10; + + if ( erg[ 0 ].dok_dat_feld_25 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF25 / Geschaeftsfuehrer [" + erg[ 0 ].dok_dat_feld_25 + "]" ); + newDoc.field[ 25 ] = erg[ 0 ].dok_dat_feld_25; + } + + if ( erg[ 0 ].dok_dat_feld_42 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF42 / Briefkopf [" + erg[ 0 ].dok_dat_feld_42 + "]" ); + newDoc.field[ 42 ] = erg[ 0 ].dok_dat_feld_42; + } + + if ( erg[ 0 ].dok_dat_feld_21 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF21 / Aktenname [" + erg[ 0 ].dok_dat_feld_21 + "]" ); + newDoc.field[ 21 ] = erg[ 0 ].dok_dat_feld_21; + } + + if ( erg[ 0 ].dok_dat_feld_2 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF2 / Mandantname [" + erg[ 0 ].dok_dat_feld_2 + "]" ); + newDoc.field[ 2 ] = erg[ 0 ].dok_dat_feld_2; + } + + if ( erg[ 0 ].dok_dat_feld_13 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF13 / Mandantgruppennummer [" + erg[ 0 ].dok_dat_feld_13 + "]" ); + newDoc.field[ 13 ] = erg[ 0 ].dok_dat_feld_13; + } + + if ( erg[ 0 ].dok_dat_feld_37 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF37 / Mandatsverantwortlicher [" + erg[ 0 ].dok_dat_feld_37 + "]" ); + newDoc.field[ 37 ] = erg[ 0 ].dok_dat_feld_37; + } + + } + else + { + lege_akte_an = false; + } + + + if ( schritte[ m ].dok_dat_feld_3 ) // Oberregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF3 / Oberregister [" + schritte[ m ].dok_dat_feld_3 + "]" ); + newDoc.field[ 3 ] = schritte[ m ].dok_dat_feld_3; + } + + if ( schritte[ m ].dok_dat_feld_4 ) // Register + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF4 / Register [" + schritte[ m ].dok_dat_feld_4 + "]" ); + newDoc.field[ 4 ] = schritte[ m ].dok_dat_feld_4; + } + + if ( schritte[ m ].dok_dat_feld_23 ) // Unterregister + { + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF23 / Unterregister [" + schritte[ m ].dok_dat_feld_23 + "]" ); + newDoc.field[ 23 ] = schritte[ m ].dok_dat_feld_23; + } + + if ( schritte[ m ].dok_dat_feld_17 ) // 2. Unterregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF17 / 2. Unterregister [" + schritte[ m ].dok_dat_feld_17 + "]" ); + newDoc.field[ 17 ] = schritte[ m ].dok_dat_feld_17; + } + + if ( schritte[ m ].dok_dat_feld_32 ) // 3. Unterregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF32 / 3. Unterregister [" + schritte[ m ].dok_dat_feld_32 + "]" ); + newDoc.field[ 32 ] = schritte[ m ].dok_dat_feld_32; + } + + def fehler = false; + + if ( debug == 0 ) + { + if ( lege_akte_an ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte konnte nicht erzeugt werden: " + e.message ); + fehler = true; + } + + if ( ! fehler ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Doku-ID der erzeugten Akte : [" + newDoc.id + "]" ); + gemerkte_doku_id = newDoc.id; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert, gemerkte Doku-ID: [" + gemerkte_doku_id + "]" ); + } + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Hauptakte wurde nicht gefunden => Akte wurde nicht erzeugt." ); + break; + } + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte wurde nicht erzeugt / Debug-Modus eingeschaltet." ); + } + } + + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ":****************************" ); + + } + } + + + if ( gemerkte_doku_id ) + { + + def USTATEMENT = "update mig_link_docs_2 set doku_id_target_fol = '" + gemerkte_doku_id + "' where id = '" + resultRows[ i ].id + "'"; + if ( debug == 0 ) + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": setze gemerkte Doku-ID [" + gemerkte_doku_id + "] fuer ID " + resultRows[ i ].id ); + d3.sql.executeAndGet( (String) USTATEMENT ); + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Debug-Modus eingeschaltet, [" + gemerkte_doku_id + "] fuer ID " + resultRows[ i ].id + " wurde nicht gesetzt."); + } + } + + if ( ! lege_akte_an ) + { + def USTATEMENT = "update mig_link_docs_2 set fehler = 'Die Hauptakte existiert nicht.' where id = '" + resultRows[ i ].id + "'"; + if ( debug == 0 ) + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": setze Fehler 'Die Hauptakte existiert nicht.' fuer ID " + resultRows[ i ].id ); + d3.sql.executeAndGet( (String) USTATEMENT ); + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Debug-Modus eingeschaltet, Fehler 'Die Hauptakte existiert nicht.' fuer ID " + resultRows[ i ].id + " wurde nicht gesetzt."); + } + } + + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ":*******************************************************" ); + } + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} \ No newline at end of file diff --git a/Kleeberg/migration_verknuepfungen_3.groovy b/Kleeberg/migration_verknuepfungen_3.groovy new file mode 100644 index 0000000..2039e3d --- /dev/null +++ b/Kleeberg/migration_verknuepfungen_3.groovy @@ -0,0 +1,566 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_verknuepfungen_3.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + +def sqlQuery = "select top (100) id,unique_id_doc,unique_id_fol,ddf10,ddf3,ddf4,ddf23,ddf17,ddf32 from mig_link_docs_2 where doku_id_target_fol is null and ddf3 is not null and ddf10 like '%DA%' and fehler is null and id >= 613985 and id < 1423048 "; + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( resultRows.size() > 0 ) +{ + for( int i = 0 ; i <= resultRows.size() - 1 ; i++ ) + { + def dummy_ddf3, dummy_ddf4, dummy_ddf23, dummy_ddf17, dummy_ddf32; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": pruefen, ob folgende Aktenstruktur existiert:" ); + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Unique-ID Dokument : [" + resultRows[ i ].unique_id_doc + "]" ); + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF10 / Aktennummer : [" + resultRows[ i ].ddf10 + "]" ); + + if ( ( ! resultRows[ i ].ddf3 ) || ( resultRows[ i ].ddf3 == "null" ) ) + { + dummy_ddf3 = ""; + } + else + { + dummy_ddf3 = resultRows[ i ].ddf3; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF03 / Oberregister : [" + dummy_ddf3 + "]" ); + + if ( ( ! resultRows[ i ].ddf4 ) || ( resultRows[ i ].ddf4 == "null" ) ) + { + dummy_ddf4 = ""; + } + else + { + dummy_ddf4 = resultRows[ i ].ddf4; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF04 / Register : [" + dummy_ddf4 + "]" ); + + if ( ( ! resultRows[ i ].ddf23 ) || ( resultRows[ i ].ddf23 == "null" ) ) + { + dummy_ddf23 = ""; + } + else + { + dummy_ddf23 = resultRows[ i ].ddf23; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF23 / Unterregister : [" + dummy_ddf23 + "]" ); + + if ( ( ! resultRows[ i ].ddf17 ) || ( resultRows[ i ].ddf17 == "null" ) ) + { + dummy_ddf17 = ""; + } + else + { + dummy_ddf17 = resultRows[ i ].ddf17; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF17 / 2. Unterregister : [" + dummy_ddf17 + "]" ); + + if ( ( ! resultRows[ i ].ddf32 ) || ( resultRows[ i ].ddf32 == "null" ) ) + { + dummy_ddf32 = ""; + } + else + { + dummy_ddf32 = resultRows[ i ].ddf32; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF32 / 3. Unterregister : [" + dummy_ddf32 + "]" ); + + def typ = resultRows[ i ].ddf10.substring(5, 7); + + xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": erkannter Typ: " + typ ); + + def orakte, rakte, urakte, urakte2, urakte3; + + + switch ( typ ) + { + case "FI": + akte = "AFIBA"; + orakte = "AFIOR"; + rakte = "AFIRA"; + urakte = "AFIUR"; + urakte2 = "AFIU2"; + urakte3 = ""; + break; + case "DA": + akte = "ADAUR"; + orakte = "AOREG"; + rakte = "AREGS"; + urakte = "AUREG"; + urakte2 = "AURG2"; + urakte3 = "AURG3"; + break; + case "ST": + akte = "ASTEU"; + orakte = "ASTOR"; + rakte = "ASTRA"; + urakte = "ASTUR"; + urakte2 = "ASTU2"; + urakte3 = ""; + break; + case "BE": + akte = "ABERB"; + orakte = "ABERO"; + rakte = "ABERA"; + urakte = "ABEUR"; + urakte2 = "ABEU2"; + urakte3 = ""; + break; + case "BP": + akte = "ABETR"; + orakte = "ABEOR"; + rakte = "ABEPA"; + urakte = "ABPUR"; + urakte2 = "ABPU2"; + urakte3 = ""; + break; + case "LO": + akte = "ALOJA"; + orakte = "ALBOR"; + rakte = "ALBRE"; + urakte = "ALJUR"; + urakte2 = "ALJR2"; + urakte3 = ""; + break; + case "LS": + akte = "ALBSA"; + orakte = "ALBSO"; + rakte = "ALORE"; + urakte = "ALOUR"; + urakte2 = "ALBU2"; + urakte3 = ""; + break; + case "JA": + akte = "AJAAA"; + orakte = "AJAOB"; + rakte = "AJAAB"; + urakte = "AJAUR"; + urakte2 = "AJAU2"; + urakte3 = ""; + break; + case "RE": + akte = "AAURE"; + orakte = "AAURR"; + rakte = "AAURA"; + urakte = "AAURU"; + urakte2 = "AAUR2"; + urakte3 = ""; + break; + } + + + + + def schritt_1 = [ "kue_dokuart": orakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3 ]; + def schritt_2 = [ "kue_dokuart": rakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4 ]; + def schritt_3 = [ "kue_dokuart": urakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23 ]; + def schritt_4 = [ "kue_dokuart": urakte2, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23, "dok_dat_feld_17": dummy_ddf17 ]; + def schritt_5 = [ "kue_dokuart": urakte3, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23, "dok_dat_feld_17": dummy_ddf17, "dok_dat_feld_32": dummy_ddf32 ]; + + def schritte = [ schritt_1, schritt_2, schritt_3, schritt_4, schritt_5 ]; + + def gemerkte_doku_id; + def lege_akte_an; + + for ( int m = 0; m <= schritte.size() - 1 ; m++ ) + { + + // Zusammenbauen des Such-Statements: + + def STATEMENT = "select doku_id from firmen_spezifisch where "; + def log = "Suche nach folgenden Kriterien : "; + def x = 0; + def und; + def kein_problem = true; + lege_akte_an = true; + + schritte[ m ].each { eintrag -> + + //xlog( d3, 3, "Key [" + eintrag.key + "] Value [" + eintrag.value + "]" ); + if ( x > 0 ) + { + und = " and "; + } + else + { + und = ""; + x = 1; + } + + if ( ( eintrag.value == "" ) || ( eintrag.value == null ) ) + { + kein_problem = false; + } + + if ( ( eintrag.key == "kue_dokuart" ) && ( eintrag.value == "" ) ) + { + kein_problem = false; + } + + STATEMENT = STATEMENT + und + eintrag.key + " = '" + eintrag.value + "' "; + log = log + "[" + eintrag.key + "] => [" + eintrag.value + "] "; + } + + if ( kein_problem ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + log ); + + xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + STATEMENT ); + + def ergebnis = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( ergebnis.size() > 0 ) + { + // Akte existiert + // Doku-ID merken: + gemerkte_doku_id = ergebnis[ 0 ].doku_id; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert, gemerkte Doku-ID: [" + gemerkte_doku_id + "]" ); + + //def updatesql = "update mig_verknuepfung set ziel_dok = '" + ergebnis[ 0 ].doku_id + "' where id = " + resultRows[ i ].id; + + } + else + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert nicht, muss angelegt werden." ); + + + // Akte existiert nicht, muss angelegt werden: + Document newDoc = d3.archive.newDocument(); + //xlog( d3, 2, "Schritte kue_dokuart = [" + schritte[ m ] + "]"); + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze Dokumentart [" + schritte[ m ].kue_dokuart + "]" ); + + newDoc.type = schritte[ m ].kue_dokuart; + + + + newDoc.status = Document.DocStatus.DOC_STAT_RELEASE; + //newDoc.editor = "dvelop"; + + // Mit diesem Statement wird versucht, die Hauptakte zu finden, um von dieser dann Eigenschaftswerte zu lesen. Kann diese Akte nicht gefunden werden, ist das ein Fehlerzustand, + // der am Datensatz in der Quelle festgehalten wird. + STATEMENT = "select doku_id, dok_dat_feld_25, dok_dat_feld_42, dok_dat_feld_21, dok_dat_feld_2, dok_dat_feld_13, dok_dat_feld_37, dok_dat_feld_1 from firmen_spezifisch where kue_dokuart = '" + akte + "' and dok_dat_feld_10 = '" + resultRows[ i ].ddf10 + "'"; + + def erg = d3.sql.executeAndGet( (String) STATEMENT ); + //xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + STATEMENT ); + + if ( schritte[ m ].dok_dat_feld_1 ) // Mandantnummer + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF1 / Mandantnummer [" + schritte[ m ].dok_dat_feld_1 + "]" ); + newDoc.field[ 1 ] = schritte[ m ].dok_dat_feld_1; + } + + + if ( erg.size() > 0 ) + { + if ( ( erg[ 0 ].dok_dat_feld_1 ) && ( ! schritte[ m ].dok_dat_feld_1 ) ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF1 / Mandantnummer [" + erg[ 0 ].dok_dat_feld_1 + "]" ); + newDoc.field[ 1 ] = erg[ 0 ].dok_dat_feld_1; + } + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF10 / Aktennummer [" + resultRows[ i ].ddf10 + "]" ); + newDoc.field[ 10 ] = resultRows[ i ].ddf10; + + if ( erg[ 0 ].dok_dat_feld_25 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF25 / Geschaeftsfuehrer [" + erg[ 0 ].dok_dat_feld_25 + "]" ); + newDoc.field[ 25 ] = erg[ 0 ].dok_dat_feld_25; + } + + if ( erg[ 0 ].dok_dat_feld_42 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF42 / Briefkopf [" + erg[ 0 ].dok_dat_feld_42 + "]" ); + newDoc.field[ 42 ] = erg[ 0 ].dok_dat_feld_42; + } + + if ( erg[ 0 ].dok_dat_feld_21 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF21 / Aktenname [" + erg[ 0 ].dok_dat_feld_21 + "]" ); + newDoc.field[ 21 ] = erg[ 0 ].dok_dat_feld_21; + } + + if ( erg[ 0 ].dok_dat_feld_2 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF2 / Mandantname [" + erg[ 0 ].dok_dat_feld_2 + "]" ); + newDoc.field[ 2 ] = erg[ 0 ].dok_dat_feld_2; + } + + if ( erg[ 0 ].dok_dat_feld_13 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF13 / Mandantgruppennummer [" + erg[ 0 ].dok_dat_feld_13 + "]" ); + newDoc.field[ 13 ] = erg[ 0 ].dok_dat_feld_13; + } + + if ( erg[ 0 ].dok_dat_feld_37 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF37 / Mandatsverantwortlicher [" + erg[ 0 ].dok_dat_feld_37 + "]" ); + newDoc.field[ 37 ] = erg[ 0 ].dok_dat_feld_37; + } + + } + else + { + lege_akte_an = false; + } + + + if ( schritte[ m ].dok_dat_feld_3 ) // Oberregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF3 / Oberregister [" + schritte[ m ].dok_dat_feld_3 + "]" ); + newDoc.field[ 3 ] = schritte[ m ].dok_dat_feld_3; + } + + if ( schritte[ m ].dok_dat_feld_4 ) // Register + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF4 / Register [" + schritte[ m ].dok_dat_feld_4 + "]" ); + newDoc.field[ 4 ] = schritte[ m ].dok_dat_feld_4; + } + + if ( schritte[ m ].dok_dat_feld_23 ) // Unterregister + { + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF23 / Unterregister [" + schritte[ m ].dok_dat_feld_23 + "]" ); + newDoc.field[ 23 ] = schritte[ m ].dok_dat_feld_23; + } + + if ( schritte[ m ].dok_dat_feld_17 ) // 2. Unterregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF17 / 2. Unterregister [" + schritte[ m ].dok_dat_feld_17 + "]" ); + newDoc.field[ 17 ] = schritte[ m ].dok_dat_feld_17; + } + + if ( schritte[ m ].dok_dat_feld_32 ) // 3. Unterregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF32 / 3. Unterregister [" + schritte[ m ].dok_dat_feld_32 + "]" ); + newDoc.field[ 32 ] = schritte[ m ].dok_dat_feld_32; + } + + def fehler = false; + + if ( debug == 0 ) + { + if ( lege_akte_an ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte konnte nicht erzeugt werden: " + e.message ); + fehler = true; + } + + if ( ! fehler ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Doku-ID der erzeugten Akte : [" + newDoc.id + "]" ); + gemerkte_doku_id = newDoc.id; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert, gemerkte Doku-ID: [" + gemerkte_doku_id + "]" ); + } + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Hauptakte wurde nicht gefunden => Akte wurde nicht erzeugt." ); + break; + } + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte wurde nicht erzeugt / Debug-Modus eingeschaltet." ); + } + } + + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ":****************************" ); + + } + } + + + if ( gemerkte_doku_id ) + { + + def USTATEMENT = "update mig_link_docs_2 set doku_id_target_fol = '" + gemerkte_doku_id + "' where id = '" + resultRows[ i ].id + "'"; + if ( debug == 0 ) + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": setze gemerkte Doku-ID [" + gemerkte_doku_id + "] fuer ID " + resultRows[ i ].id ); + d3.sql.executeAndGet( (String) USTATEMENT ); + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Debug-Modus eingeschaltet, [" + gemerkte_doku_id + "] fuer ID " + resultRows[ i ].id + " wurde nicht gesetzt."); + } + } + + if ( ! lege_akte_an ) + { + def USTATEMENT = "update mig_link_docs_2 set fehler = 'Die Hauptakte existiert nicht.' where id = '" + resultRows[ i ].id + "'"; + if ( debug == 0 ) + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": setze Fehler 'Die Hauptakte existiert nicht.' fuer ID " + resultRows[ i ].id ); + d3.sql.executeAndGet( (String) USTATEMENT ); + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Debug-Modus eingeschaltet, Fehler 'Die Hauptakte existiert nicht.' fuer ID " + resultRows[ i ].id + " wurde nicht gesetzt."); + } + } + + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ":*******************************************************" ); + } + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} \ No newline at end of file diff --git a/Kleeberg/migration_verknuepfungen_4.groovy b/Kleeberg/migration_verknuepfungen_4.groovy new file mode 100644 index 0000000..c45ce81 --- /dev/null +++ b/Kleeberg/migration_verknuepfungen_4.groovy @@ -0,0 +1,566 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_verknuepfungen_4.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + +def sqlQuery = "select top (100) id,unique_id_doc,unique_id_fol,ddf10,ddf3,ddf4,ddf23,ddf17,ddf32 from mig_link_docs_2 where doku_id_target_fol is null and ddf3 is not null and ddf10 like '%DA%' and fehler is null and id >= 1423048 "; + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + +xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); +xlog( d3, 4, "************************************************" ); + +if ( resultRows.size() > 0 ) +{ + for( int i = 0 ; i <= resultRows.size() - 1 ; i++ ) + { + def dummy_ddf3, dummy_ddf4, dummy_ddf23, dummy_ddf17, dummy_ddf32; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": pruefen, ob folgende Aktenstruktur existiert:" ); + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Unique-ID Dokument : [" + resultRows[ i ].unique_id_doc + "]" ); + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF10 / Aktennummer : [" + resultRows[ i ].ddf10 + "]" ); + + if ( ( ! resultRows[ i ].ddf3 ) || ( resultRows[ i ].ddf3 == "null" ) ) + { + dummy_ddf3 = ""; + } + else + { + dummy_ddf3 = resultRows[ i ].ddf3; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF03 / Oberregister : [" + dummy_ddf3 + "]" ); + + if ( ( ! resultRows[ i ].ddf4 ) || ( resultRows[ i ].ddf4 == "null" ) ) + { + dummy_ddf4 = ""; + } + else + { + dummy_ddf4 = resultRows[ i ].ddf4; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF04 / Register : [" + dummy_ddf4 + "]" ); + + if ( ( ! resultRows[ i ].ddf23 ) || ( resultRows[ i ].ddf23 == "null" ) ) + { + dummy_ddf23 = ""; + } + else + { + dummy_ddf23 = resultRows[ i ].ddf23; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF23 / Unterregister : [" + dummy_ddf23 + "]" ); + + if ( ( ! resultRows[ i ].ddf17 ) || ( resultRows[ i ].ddf17 == "null" ) ) + { + dummy_ddf17 = ""; + } + else + { + dummy_ddf17 = resultRows[ i ].ddf17; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF17 / 2. Unterregister : [" + dummy_ddf17 + "]" ); + + if ( ( ! resultRows[ i ].ddf32 ) || ( resultRows[ i ].ddf32 == "null" ) ) + { + dummy_ddf32 = ""; + } + else + { + dummy_ddf32 = resultRows[ i ].ddf32; + } + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": DDF32 / 3. Unterregister : [" + dummy_ddf32 + "]" ); + + def typ = resultRows[ i ].ddf10.substring(5, 7); + + xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": erkannter Typ: " + typ ); + + def orakte, rakte, urakte, urakte2, urakte3; + + + switch ( typ ) + { + case "FI": + akte = "AFIBA"; + orakte = "AFIOR"; + rakte = "AFIRA"; + urakte = "AFIUR"; + urakte2 = "AFIU2"; + urakte3 = ""; + break; + case "DA": + akte = "ADAUR"; + orakte = "AOREG"; + rakte = "AREGS"; + urakte = "AUREG"; + urakte2 = "AURG2"; + urakte3 = "AURG3"; + break; + case "ST": + akte = "ASTEU"; + orakte = "ASTOR"; + rakte = "ASTRA"; + urakte = "ASTUR"; + urakte2 = "ASTU2"; + urakte3 = ""; + break; + case "BE": + akte = "ABERB"; + orakte = "ABERO"; + rakte = "ABERA"; + urakte = "ABEUR"; + urakte2 = "ABEU2"; + urakte3 = ""; + break; + case "BP": + akte = "ABETR"; + orakte = "ABEOR"; + rakte = "ABEPA"; + urakte = "ABPUR"; + urakte2 = "ABPU2"; + urakte3 = ""; + break; + case "LO": + akte = "ALOJA"; + orakte = "ALBOR"; + rakte = "ALBRE"; + urakte = "ALJUR"; + urakte2 = "ALJR2"; + urakte3 = ""; + break; + case "LS": + akte = "ALBSA"; + orakte = "ALBSO"; + rakte = "ALORE"; + urakte = "ALOUR"; + urakte2 = "ALBU2"; + urakte3 = ""; + break; + case "JA": + akte = "AJAAA"; + orakte = "AJAOB"; + rakte = "AJAAB"; + urakte = "AJAUR"; + urakte2 = "AJAU2"; + urakte3 = ""; + break; + case "RE": + akte = "AAURE"; + orakte = "AAURR"; + rakte = "AAURA"; + urakte = "AAURU"; + urakte2 = "AAUR2"; + urakte3 = ""; + break; + } + + + + + def schritt_1 = [ "kue_dokuart": orakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3 ]; + def schritt_2 = [ "kue_dokuart": rakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4 ]; + def schritt_3 = [ "kue_dokuart": urakte, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23 ]; + def schritt_4 = [ "kue_dokuart": urakte2, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23, "dok_dat_feld_17": dummy_ddf17 ]; + def schritt_5 = [ "kue_dokuart": urakte3, "dok_dat_feld_10": resultRows[ i ].ddf10, "dok_dat_feld_3": dummy_ddf3, "dok_dat_feld_4": dummy_ddf4, "dok_dat_feld_23": dummy_ddf23, "dok_dat_feld_17": dummy_ddf17, "dok_dat_feld_32": dummy_ddf32 ]; + + def schritte = [ schritt_1, schritt_2, schritt_3, schritt_4, schritt_5 ]; + + def gemerkte_doku_id; + def lege_akte_an; + + for ( int m = 0; m <= schritte.size() - 1 ; m++ ) + { + + // Zusammenbauen des Such-Statements: + + def STATEMENT = "select doku_id from firmen_spezifisch where "; + def log = "Suche nach folgenden Kriterien : "; + def x = 0; + def und; + def kein_problem = true; + lege_akte_an = true; + + schritte[ m ].each { eintrag -> + + //xlog( d3, 3, "Key [" + eintrag.key + "] Value [" + eintrag.value + "]" ); + if ( x > 0 ) + { + und = " and "; + } + else + { + und = ""; + x = 1; + } + + if ( ( eintrag.value == "" ) || ( eintrag.value == null ) ) + { + kein_problem = false; + } + + if ( ( eintrag.key == "kue_dokuart" ) && ( eintrag.value == "" ) ) + { + kein_problem = false; + } + + STATEMENT = STATEMENT + und + eintrag.key + " = '" + eintrag.value + "' "; + log = log + "[" + eintrag.key + "] => [" + eintrag.value + "] "; + } + + if ( kein_problem ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + log ); + + xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + STATEMENT ); + + def ergebnis = d3.sql.executeAndGet( (String) STATEMENT ); + + if ( ergebnis.size() > 0 ) + { + // Akte existiert + // Doku-ID merken: + gemerkte_doku_id = ergebnis[ 0 ].doku_id; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert, gemerkte Doku-ID: [" + gemerkte_doku_id + "]" ); + + //def updatesql = "update mig_verknuepfung set ziel_dok = '" + ergebnis[ 0 ].doku_id + "' where id = " + resultRows[ i ].id; + + } + else + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert nicht, muss angelegt werden." ); + + + // Akte existiert nicht, muss angelegt werden: + Document newDoc = d3.archive.newDocument(); + //xlog( d3, 2, "Schritte kue_dokuart = [" + schritte[ m ] + "]"); + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze Dokumentart [" + schritte[ m ].kue_dokuart + "]" ); + + newDoc.type = schritte[ m ].kue_dokuart; + + + + newDoc.status = Document.DocStatus.DOC_STAT_RELEASE; + //newDoc.editor = "dvelop"; + + // Mit diesem Statement wird versucht, die Hauptakte zu finden, um von dieser dann Eigenschaftswerte zu lesen. Kann diese Akte nicht gefunden werden, ist das ein Fehlerzustand, + // der am Datensatz in der Quelle festgehalten wird. + STATEMENT = "select doku_id, dok_dat_feld_25, dok_dat_feld_42, dok_dat_feld_21, dok_dat_feld_2, dok_dat_feld_13, dok_dat_feld_37, dok_dat_feld_1 from firmen_spezifisch where kue_dokuart = '" + akte + "' and dok_dat_feld_10 = '" + resultRows[ i ].ddf10 + "'"; + + def erg = d3.sql.executeAndGet( (String) STATEMENT ); + //xlog( d3, 5, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": " + STATEMENT ); + + if ( schritte[ m ].dok_dat_feld_1 ) // Mandantnummer + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF1 / Mandantnummer [" + schritte[ m ].dok_dat_feld_1 + "]" ); + newDoc.field[ 1 ] = schritte[ m ].dok_dat_feld_1; + } + + + if ( erg.size() > 0 ) + { + if ( ( erg[ 0 ].dok_dat_feld_1 ) && ( ! schritte[ m ].dok_dat_feld_1 ) ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF1 / Mandantnummer [" + erg[ 0 ].dok_dat_feld_1 + "]" ); + newDoc.field[ 1 ] = erg[ 0 ].dok_dat_feld_1; + } + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF10 / Aktennummer [" + resultRows[ i ].ddf10 + "]" ); + newDoc.field[ 10 ] = resultRows[ i ].ddf10; + + if ( erg[ 0 ].dok_dat_feld_25 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF25 / Geschaeftsfuehrer [" + erg[ 0 ].dok_dat_feld_25 + "]" ); + newDoc.field[ 25 ] = erg[ 0 ].dok_dat_feld_25; + } + + if ( erg[ 0 ].dok_dat_feld_42 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF42 / Briefkopf [" + erg[ 0 ].dok_dat_feld_42 + "]" ); + newDoc.field[ 42 ] = erg[ 0 ].dok_dat_feld_42; + } + + if ( erg[ 0 ].dok_dat_feld_21 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF21 / Aktenname [" + erg[ 0 ].dok_dat_feld_21 + "]" ); + newDoc.field[ 21 ] = erg[ 0 ].dok_dat_feld_21; + } + + if ( erg[ 0 ].dok_dat_feld_2 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF2 / Mandantname [" + erg[ 0 ].dok_dat_feld_2 + "]" ); + newDoc.field[ 2 ] = erg[ 0 ].dok_dat_feld_2; + } + + if ( erg[ 0 ].dok_dat_feld_13 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF13 / Mandantgruppennummer [" + erg[ 0 ].dok_dat_feld_13 + "]" ); + newDoc.field[ 13 ] = erg[ 0 ].dok_dat_feld_13; + } + + if ( erg[ 0 ].dok_dat_feld_37 ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF37 / Mandatsverantwortlicher [" + erg[ 0 ].dok_dat_feld_37 + "]" ); + newDoc.field[ 37 ] = erg[ 0 ].dok_dat_feld_37; + } + + } + else + { + lege_akte_an = false; + } + + + if ( schritte[ m ].dok_dat_feld_3 ) // Oberregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF3 / Oberregister [" + schritte[ m ].dok_dat_feld_3 + "]" ); + newDoc.field[ 3 ] = schritte[ m ].dok_dat_feld_3; + } + + if ( schritte[ m ].dok_dat_feld_4 ) // Register + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF4 / Register [" + schritte[ m ].dok_dat_feld_4 + "]" ); + newDoc.field[ 4 ] = schritte[ m ].dok_dat_feld_4; + } + + if ( schritte[ m ].dok_dat_feld_23 ) // Unterregister + { + + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF23 / Unterregister [" + schritte[ m ].dok_dat_feld_23 + "]" ); + newDoc.field[ 23 ] = schritte[ m ].dok_dat_feld_23; + } + + if ( schritte[ m ].dok_dat_feld_17 ) // 2. Unterregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF17 / 2. Unterregister [" + schritte[ m ].dok_dat_feld_17 + "]" ); + newDoc.field[ 17 ] = schritte[ m ].dok_dat_feld_17; + } + + if ( schritte[ m ].dok_dat_feld_32 ) // 3. Unterregister + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Setze DDF32 / 3. Unterregister [" + schritte[ m ].dok_dat_feld_32 + "]" ); + newDoc.field[ 32 ] = schritte[ m ].dok_dat_feld_32; + } + + def fehler = false; + + if ( debug == 0 ) + { + if ( lege_akte_an ) + { + try + { + newDoc = d3.archive.importDocument( newDoc ); + } + catch ( D3Exception e ) + { + xlog( d3, 2, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte konnte nicht erzeugt werden: " + e.message ); + fehler = true; + } + + if ( ! fehler ) + { + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Doku-ID der erzeugten Akte : [" + newDoc.id + "]" ); + gemerkte_doku_id = newDoc.id; + xlog( d3, 4, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte existiert, gemerkte Doku-ID: [" + gemerkte_doku_id + "]" ); + } + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Hauptakte wurde nicht gefunden => Akte wurde nicht erzeugt." ); + break; + } + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Akte wurde nicht erzeugt / Debug-Modus eingeschaltet." ); + } + } + + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ":****************************" ); + + } + } + + + if ( gemerkte_doku_id ) + { + + def USTATEMENT = "update mig_link_docs_2 set doku_id_target_fol = '" + gemerkte_doku_id + "' where id = '" + resultRows[ i ].id + "'"; + if ( debug == 0 ) + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": setze gemerkte Doku-ID [" + gemerkte_doku_id + "] fuer ID " + resultRows[ i ].id ); + d3.sql.executeAndGet( (String) USTATEMENT ); + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Debug-Modus eingeschaltet, [" + gemerkte_doku_id + "] fuer ID " + resultRows[ i ].id + " wurde nicht gesetzt."); + } + } + + if ( ! lege_akte_an ) + { + def USTATEMENT = "update mig_link_docs_2 set fehler = 'Die Hauptakte existiert nicht.' where id = '" + resultRows[ i ].id + "'"; + if ( debug == 0 ) + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": setze Fehler 'Die Hauptakte existiert nicht.' fuer ID " + resultRows[ i ].id ); + d3.sql.executeAndGet( (String) USTATEMENT ); + } + else + { + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ": Debug-Modus eingeschaltet, Fehler 'Die Hauptakte existiert nicht.' fuer ID " + resultRows[ i ].id + " wurde nicht gesetzt."); + } + } + + xlog( d3, 3, resultRows[ i ].ddf10 + " / " + resultRows[ i ].id + ":*******************************************************" ); + } + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} \ No newline at end of file diff --git a/Kleeberg/migration_verknuepfungen_schneller.groovy b/Kleeberg/migration_verknuepfungen_schneller.groovy new file mode 100644 index 0000000..2e69cb9 --- /dev/null +++ b/Kleeberg/migration_verknuepfungen_schneller.groovy @@ -0,0 +1,181 @@ +import com.dvelop.d3.server.Document +import com.dvelop.d3.server.core.D3Interface +import com.dvelop.d3.server.exceptions.SQLException +import com.dvelop.d3.server.exceptions.D3Exception +import groovy.transform.Field + +D3Interface d3 = getProperty("d3"); + +@Field prg = "migration_verknuepfungen_schneller.groovy"; +@Field version = "0.1"; +@Field kunde = "Dr. Kleeberg & Partner GmbH"; + +///////////////////////////////////////////////////////////////////////// + + +// debug = 0 => es finden Änderungen am Datenbestand statt +// debug = 1 => es finden keine Änderungen am Datenbestand statt +@Field debug = 0; + + + + + + +///////////////////////////////////////////////////////////////////////// + +def debugtext; + +switch (debug) +{ + case 0: + debugtext = "ausgeschaltet"; + break; + default: + debugtext = "eingeschaltet (keine Aenderungen am Datenbestand)"; + break; +} + + + +xlog( d3, 4, "************************************************" ); +xlog( d3, 4, "* Programm : " + prg ); +xlog( d3, 4, "* Version : " + version ); +xlog( d3, 4, "* Kunde : " + kunde ); +xlog( d3, 4, "* geschrieben von : calb / d.velop AG" ); +xlog( d3, 4, "* (c) d.velop AG" ); +xlog( d3, 4, "************************************************" ); + + +xlog( d3, 4, "Parameter: " ); +xlog( d3, 4, "* DEBUG : " + debugtext ); + + + + +xlog( d3, 4, "************************************************" ); + + +def i, ergebniszeilen, ergebnistext; + +def sqlQuery = "select distinct m.ddf10, f.doku_id from mig_link_docs_2 m , firmen_spezifisch f where f.dok_dat_feld_10 = m.ddf10 and m.ddf10 like '[0-9][0-9][0-9][0-9][0-9][B][E][0-9][0-9][0-9][0-9][0-9][0-9]' and f.kue_dokuart = 'ABERB' "; //and m.ddf10 = '13292BE000400'"; + +resultRows = d3.sql.executeAndGet( (String) sqlQuery ); + +if ( resultRows.size() > 0 ) +{ + xlog( d3, 4, " Es wurden " + resultRows.size() + " Treffer gefunden." ); + xlog( d3, 4, "************************************************" ); + + for ( i = 0; i < resultRows.size(); i++ ) + { + def STATEMENT = "update mig_link_docs_2 set doku_id_target_fol = '" + resultRows[ i ].doku_id + "' where ddf10 = '" + resultRows[ i ].ddf10 + "' and doku_id_target_fol is null"; + + xlog( d3, 4, "Nr. " + i + ": " + STATEMENT ); + + def erg = d3.sql.execute( (String) STATEMENT ); + xlog( d3, 4, "Nr. " + i + ": " + erg + " Datensaetze wurden aktualisiert." ); + } + + +} +else +{ + xlog( d3, 3, "Es wurden keine passenden Treffer gefunden!" ); +} + + + + + + + + + + + + + + + + + + + + + + + + + + + +def xlog( D3Interface d3, int loglevel, String logtext ) +{ + def logdatei = "d:\\d3\\apps\\" + prg + ".txt"; + def g_loglevel = 5; + def g_logdirect = "BEIDE"; // BEIDE oder D3LOG oder DATEI + def date = new Date(); + def zeitstempel = date.format( "yyyy.MM.dd HH:mm:ss", TimeZone.getTimeZone('CET') ); + def loglevel_lang = "[INFO ]"; + + + + + + if ( loglevel <= g_loglevel ) + { + switch ( loglevel ) + { + case 1: + loglevel_lang = "[FATAL]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.critical( logtext ); + } + break; + case 2: + loglevel_lang = "[ERROR]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.error( logtext ); + } + break; + case 3: + loglevel_lang = "[WARN ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.warn( logtext ); + } + break; + case 4: + loglevel_lang = "[INFO ]"; + + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.info( logtext ); + } + break; + case 5: + loglevel_lang = "[DEBUG]"; + // Da die d.3 Server i.d.R. nicht im Debug-Modus laufen, erscheinen DEBUG-Meldungen nicht im Log. + if ( ( g_logdirect == "D3LOG" ) || ( g_logdirect == "BEIDE" ) ) + { + d3.log.debug( logtext ); + } + break; + } + + } + + if ( ( g_logdirect == "DATEI" ) || ( g_logdirect == "BEIDE" ) ) + { + new File( logdatei ).append( zeitstempel + " " + loglevel_lang + " " + logtext + "\n", "UTF8" ); + } + + + return 0; +} \ No newline at end of file