9322 lines
418 KiB
Groovy
9322 lines
418 KiB
Groovy
import java.lang.invoke.ConstantCallSite
|
|
|
|
// --------------------------------------------------------------------------------------------------------
|
|
// Functions.groovy
|
|
// --------------------------------------------------------------------------------------------------------
|
|
// Historie:
|
|
// 29.04.2019 imue/dvelop Initiale Umstellung einzelner Einstiegspunkte auf Groovy
|
|
//
|
|
// --------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
import com.dvelop.d3.server.Document
|
|
import com.dvelop.d3.server.DocumentType
|
|
import com.dvelop.d3.server.Entrypoint
|
|
import com.dvelop.d3.server.User
|
|
import com.dvelop.d3.server.core.D3Interface
|
|
import com.dvelop.d3.server.core.D3.Archive
|
|
import com.dvelop.d3.server.core.D3Interface.StorageManagerInterface
|
|
|
|
import groovy.sql.GroovyRowResult
|
|
import com.dvelop.d3.server.exceptions.SQLException
|
|
import com.dvelop.d3.server.exceptions.D3Exception
|
|
|
|
import java.util.Calendar.*
|
|
import java.util.concurrent.atomic.DoubleAdder
|
|
import java.util.regex.Pattern.First
|
|
import java.awt.Component.BaselineResizeBehavior
|
|
import java.text.SimpleDateFormat
|
|
import java.time.chrono.AbstractChronology
|
|
import java.nio.file.Path
|
|
import java.nio.file.Paths
|
|
import java.nio.channels.FileChannel
|
|
import java.sql.Timestamp
|
|
import org.apache.commons.lang.StringEscapeUtils
|
|
import java.nio.file.StandardCopyOption
|
|
import java.nio.file.Files
|
|
|
|
// zusätzliche Imports für oData Zugriff 21.01.2019
|
|
import java.io.InputStreamReader;
|
|
import java.io.Reader;
|
|
import java.net.URL;
|
|
import java.net.URLConnection;
|
|
import javax.net.ssl.HostnameVerifier;
|
|
import javax.net.ssl.HttpsURLConnection;
|
|
import javax.net.ssl.SSLContext;
|
|
import javax.net.ssl.SSLSession;
|
|
import javax.net.ssl.TrustManager;
|
|
import javax.net.ssl.X509TrustManager;
|
|
import java.security.cert.X509Certificate;
|
|
import org.json.JSONArray;
|
|
import org.json.JSONObject;
|
|
import org.apache.commons.io.IOUtils;
|
|
|
|
|
|
|
|
public class Functions {
|
|
|
|
// hinzugefügt von calb/d.velop zur Verwendung in checkIfRepoIDExistsInDocType()
|
|
public static Map<String, Boolean> RepoInDocTypeList = new HashMap<>();
|
|
|
|
/**
|
|
* Ergänzt Eigenschaften in einer JPL Datei, wenn diese in der Dokumentart existiert
|
|
* @author Hilfsfunktion
|
|
* @return keine Rückgabe - im Hintergrund wird die JPL Datei erweitert
|
|
*/
|
|
public static void appendJplIfAttribExists( D3Interface d3, Document doc, DocumentType docType, File lPathJPL, int repoId, int dbPos, String value ) {
|
|
d3.log.info("Start Functions appendJplIfAttribExists");
|
|
|
|
boolean attribExists = checkIfRepoIDExistsInDocType(d3, docType, repoId);
|
|
if(attribExists == true) {
|
|
try {
|
|
lPathJPL.append( "dok_dat_feld[${dbPos}] = \"" + value + "\"" + System.lineSeparator());
|
|
} catch(Exception e) {
|
|
d3.log.error("appendJplIfAttribExists can't append to file = " + lPathJPL);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prüfung ob es den Lieferanten (Akte - Projektlieferant) bereits gibt
|
|
* @author
|
|
* @see NewVersionEntry
|
|
* @return "OK"= nicht vorhanden; "FEHLER"=bereits vorhanden
|
|
*/
|
|
public static String checkDuplikateLieferant( D3Interface d3, Document doc, def pEntry, def pUser, def pDocId ) {
|
|
d3.log.info("Start Functions checkDuplikateLieferant");
|
|
|
|
def lRecordCount
|
|
def lAndClause = ""
|
|
|
|
if( doc.field[Const.gDDF_AUFTRNR] != null && !doc.field[Const.gDDF_AUFTRNR].equals("") ) {
|
|
lAndClause = "AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '${doc.field[Const.gDDF_AUFTRNR]}' "
|
|
} else if( doc.field[Const.gDDF_OPPNUMMER] != null && !doc.field[Const.gDDF_OPPNUMMER].equals("") ) {
|
|
lAndClause = "AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${doc.field[Const.gDDF_OPPNUMMER]}' "
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_LNR] == null ) {
|
|
lAndClause = lAndClause + " AND (dok_dat_feld_${Const.gDDF_LNR} IS NULL OR dok_dat_feld_${Const.gDDF_LNR} = '') "
|
|
} else {
|
|
lAndClause = lAndClause + " AND dok_dat_feld_${Const.gDDF_LNR} = '${doc.field[Const.gDDF_LNR]}' "
|
|
}
|
|
|
|
if( pDocId != null && ( pEntry.equals("update") || pEntry.equals("newversion") ) ) {
|
|
lAndClause = lAndClause + " AND doku_id <> '${pDocId}' "
|
|
}
|
|
|
|
def sqlStatement = "SELECT * " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ALIKO}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_LNAME} = '${doc.field[Const.gDDF_LNAME]}' " + lAndClause
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
|
|
if( sqlResult != null && sqlResult.size() > 0 && pEntry.equals("insert") ) {
|
|
d3.log.error( "Es gibt bereits einen Eintrag. Ablage wird nicht erlaubt." )
|
|
return "Fehler"
|
|
} else if( sqlResult != null && sqlResult.size() > 0 && ( pEntry.equals("update") || pEntry.equals("newversion") ) ) {
|
|
d3.log.error( "Es gibt bereits einen Eintrag. Ablage wird nicht erlaubt." )
|
|
return "Fehler"
|
|
} else {
|
|
// d3.log.error( "Ablage erlaubt, kein Duplikat gefunden." )
|
|
return "OK"
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Prüfung der Gültigkeit der Vertragsnummer
|
|
* @author Unterstützende Prozesse
|
|
* @see ValidateInsertEntry, InsertEntry
|
|
* @return 0=gültig; 10=ungültig
|
|
*/
|
|
public static int checkContractNumber(D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions checkContractNumber");
|
|
|
|
String[] splittedString = doc.field[Const.gDDF_CONTRACTNO].split("\\|")
|
|
if(splittedString != null && splittedString.size() > 0) {
|
|
doc.field[Const.gDDF_CONTRACTNO] = splittedString[0].trim();
|
|
}
|
|
|
|
def sqlStatement = "SELECT * FROM firmen_spezifisch where dok_dat_feld_${Const.gDDF_CONTRACTNO} = '${doc.field[Const.gDDF_CONTRACTNO]}' and kue_dokuart in ('${Const.gDTS_EVERT}','${Const.gDTS_RVERT}') "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
|
|
if( sqlResult == null || sqlResult.size() == 0 ) {
|
|
return 10
|
|
} else {
|
|
return 0
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Organisation D3L-Dateien
|
|
* @author
|
|
* @see UpdateAttributExit, NewVersionExit
|
|
* @return keine Rückgabe; im Hintergrund wird eine D3L-Datei erstellt, gesperrt oder entsperrt
|
|
*/
|
|
public static int checkForLinkFiles(D3Interface d3, Document doc, DocumentType docType, Document docTemp) {
|
|
d3.log.info("Start Functions checkForLinkFiles");
|
|
|
|
def lReturn
|
|
def lCopyCount
|
|
List<String> lCopyDokID
|
|
def lBlockInfo
|
|
def lOppNo
|
|
def lOppNoOld
|
|
def lProjNo
|
|
def lProjNoOld
|
|
def lFileExt = doc.getFileExtension()
|
|
|
|
if( lFileExt != null && !lFileExt.equals("d3l") && !lFileExt.equals("D3L") ) {
|
|
|
|
// Beispiel: Wenn aus einer anderen Dokumentart ein Kundenkontaktdokument wird, müssen nachträglich die D3L Dateien erzeugt werden
|
|
if( docType.getId().equals(Const.gDTS_DKUKO) && ( !docTemp.getType().getId().equals(Const.gDTS_DKUKO) || !docTemp.field[Const.gDDF_KONTAKTNUMMER].equals(doc.field[Const.gDDF_KONTAKTNUMMER]) ) ) {
|
|
|
|
List<String> lOppNR = new ArrayList<>();
|
|
def lOppCount
|
|
def lKuKoID = doc.field[Const.gDDF_KONTAKTNUMMER];
|
|
def lOppNRMain = doc.field[Const.gDDF_OPPNUMMER];
|
|
def lProjNrMain = doc.field[Const.gDDF_AUFTRNR];
|
|
def lKdNummerMain = doc.field[Const.gDDF_KNR];
|
|
List<String> lProjNr = new ArrayList<>();
|
|
List<String> lProzess = new ArrayList<>();
|
|
List<String> lDokIdRef = new ArrayList<>();
|
|
List<String> lKdName = new ArrayList<>();
|
|
List<String> lKdNummer = new ArrayList<>();
|
|
|
|
def sqlStatement = "SELECT doku_id as lDokIdRef, dok_dat_feld_${Const.gDDF_OPPNUMMER} as lOppNR, dok_dat_feld_${Const.gDDF_AUFTRNR} as lProjNr, dok_dat_feld_${Const.gDDF_PROZESS} as lProzess, dok_dat_feld_${Const.gDDF_KNAME} as lKdName, dok_dat_feld_${Const.gDDF_KNR} as lKdNummer " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_KONTAKTNUMMER} = '${lKuKoID}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AKONT}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lDokIdRef.add(grr.get("lDokIdRef"));
|
|
lOppNR.add(grr.get("lOppNR"));
|
|
lProjNr.add(grr.get("lProjNr"));
|
|
lProzess.add(grr.get("lProzess"));
|
|
lKdName.add(grr.get("lKdName"));
|
|
lKdNummer.add(grr.get("lKdNummer"));
|
|
}
|
|
|
|
lOppCount = sqlResult.size();
|
|
|
|
// Es ist nur notwendig das Kundenkontaktdokument zu clonen, falls es mehr als eine passende Akte hierzu gibt
|
|
if( lOppCount > 1 ) {
|
|
for(int i = 0; i < lOppCount; i++) {
|
|
if( !lOppNRMain.equals(lOppNR.get(i)) && lProzess.get(i).equals("0201") ) {
|
|
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
def sqlStatementOppNummer = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNR.get(i)}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '{doc.id()}%' OR pd.text like '%{doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
List<GroovyRowResult> sqlResultOppNummer = d3.getSql().executeAndGet(sqlStatementOppNummer)
|
|
lCopyCount = sqlResultOppNummer.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultOppNummer) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Opportunityakte ${lOppNR.get(i)}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("g") ) {
|
|
lReturn = docCopy.block(false, "d3groovy") // 0 = entsperren
|
|
if( lReturn != 0 ) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Entsperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
createLinkFiles(d3, doc.id(), lOppNR.get(i), lProjNr.get(i), lProzess.get(i), lDokIdRef.get(i), lKdName.get(i), lKdNummer.get(i), "", "")
|
|
}
|
|
}
|
|
else if( !lProjNrMain.equals(lProjNr.get(i)) && lProzess.get(i).equals("0202") ) {
|
|
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
def sqlStatementProjNummer = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lProjNr.get(i)}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '{doc.id()}%' OR pd.text like '%{doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
List<GroovyRowResult> sqlResultProjNummer = d3.getSql().executeAndGet(sqlStatementProjNummer)
|
|
lCopyCount = sqlResultProjNummer.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultProjNummer) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Maschinenprojektakte ${lProjNr.get(i)}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
|
|
d3.log.info("lProjNrMain - " + lBlockInfo);
|
|
if( lBlockInfo.equals("g") ) {
|
|
lReturn = docCopy.block(false, "d3groovy") // 0 = entsperren
|
|
d3.log.info("lProjNrMain - " + lReturn);
|
|
if( lReturn != 0 ) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Entsperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
createLinkFiles(d3, doc.id(), lOppNR.get(i), lProjNr.get(i), lProzess.get(i), lDokIdRef.get(i), lKdName.get(i), lKdNummer.get(i), "", "")
|
|
}
|
|
|
|
} else if( !lKdNummerMain.equals(lKdNummer.get(i)) && lProzess.get(i).equals("0200") ) {
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
def sqlStatementKdNummer = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_KNR} = '${lKdNummer.get(i)}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '{doc.id()}%' OR pd.text like '%{doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
List<GroovyRowResult> sqlResultKdNummer = d3.getSql().executeAndGet(sqlStatementKdNummer)
|
|
lCopyCount = sqlResultKdNummer.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultKdNummer) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Kundenmanagamentakte ${lKdNummer.get(i)}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("g") ) {
|
|
lReturn = docCopy.block(false, "d3groovy") // 0 = entsperren
|
|
if( lReturn != 0 ) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Entsperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
createLinkFiles(d3, doc.id(), lOppNR.get(i), lProjNr.get(i), lProzess.get(i), lDokIdRef.get(i), lKdName.get(i), lKdNummer.get(i), "", "")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// wenn sich die Kundenkontakt-ID geändert hat und es gibt bereits D3L Dateien, müssen diese auf "Freigabe gesperrt" gesetzt werden
|
|
if( !doc.field[Const.gDDF_KONTAKTNUMMER].equals(docTemp.field[Const.gDDF_KONTAKTNUMMER]) ) {
|
|
|
|
List<String> lFoundDocID = new ArrayList<>();
|
|
def lRowCountSec
|
|
def lReturnSec
|
|
|
|
def sqlStatementSec = "SELECT fs.doku_id as lFoundDocID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE pd.doku_id = fs.doku_id " +
|
|
"AND pd.text like '%${doc.id()}%' " +
|
|
"AND ( pd.datei_erw = 'D3L' " +
|
|
"OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_KONTAKTNUMMER} = '${docTemp.field[Const.gDDF_KONTAKTNUMMER]}' "
|
|
|
|
List<GroovyRowResult> sqlResultSec = d3.sql.executeAndGet(sqlStatementSec);
|
|
lRowCountSec = sqlResultSec.size()
|
|
for(GroovyRowResult grr : sqlResultSec) {
|
|
lFoundDocID.add(grr.get("lFoundDocID"))
|
|
}
|
|
|
|
for(int lRound = 0; lRound < lRowCountSec; lRound++) {
|
|
lReturn = d3.call.document_block (true, "d3groovy", lFoundDocID.get(lRound));
|
|
if( lReturn != 0 ) {
|
|
d3.log.error("Das Dokument ${lFoundDocID.get(lRound)} konnte nicht gesperrt werden! Errorcode ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
for( int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
|
|
// 13.07.2020: Durch Ergänzungen für den Service muss hier explizit geprüft werden, ob es die Eigenschaft in der Dokumentart gibt
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitOpportunityID) ) {
|
|
if( !doc.field[Const.gDDF_OPPNRM][i].equals(docTemp.field[Const.gDDF_OPPNRM][i]) && (!doc.field[Const.gDDF_OPPNRM][i].equals("") && doc.field[Const.gDDF_OPPNRM][i] != null)
|
|
&& !docType.getId().equals(Const.gDTS_DMAUF)
|
|
&& !docType.getId().equals(Const.gDTS_DMDOK)
|
|
&& !docType.getId().equals(Const.gDTS_DMSPE) ) {
|
|
|
|
lOppNo = doc.field[Const.gDDF_OPPNRM][i]
|
|
lOppNoOld = docTemp.field[Const.gDDF_OPPNRM][i]
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
if( lOppNoOld != null && !lOppNoOld.equals("") ) {
|
|
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNoOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der alten Opportunityakte ${lOppNoOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
// JPL -> api_function("attribute_get_single", "doc_status_info", "", lCopyDokID[lCount], "d3groovy")
|
|
// 0 = gesperrt (Groovy 'g') | 1 = freigegeben (Groovy 'f')
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
lReturn = docCopy.block(true, "d3groovy") // 1 = sperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
// es existiert keine d3l Datei, also nichts zu tun
|
|
}
|
|
}
|
|
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNo}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '{doc.id()}%' OR pd.text like '%{doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Opportunityakte ${lOppNo}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("g") ) {
|
|
lReturn = docCopy.block(false, "d3groovy") // 0 = entsperren
|
|
if( lReturn != 0 ) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Entsperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
createLinkFiles( d3, doc.id(), lOppNo, "", "", "", "", "", "", "")
|
|
}
|
|
|
|
} else if( !doc.field[Const.gDDF_OPPNRM][i].equals(docTemp.field[Const.gDDF_OPPNRM][i]) && (doc.field[Const.gDDF_OPPNRM][i].equals("") || doc.field[Const.gDDF_OPPNRM][i] == null) && !docType.getId().equals(Const.gDTS_DMAUF) && !docType.getId().equals(Const.gDTS_DMDOK) && !docType.getId().equals(Const.gDTS_DMSPE) ) {
|
|
// Sperrung der d3l Datei, wenn die Opportunity Nummer entfernt wird
|
|
lOppNo = doc.field[Const.gDDF_OPPNRM][i]
|
|
lOppNoOld = docTemp.field[Const.gDDF_OPPNRM][i]
|
|
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNoOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if ( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Opportunityakte ${lOppNoOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
lBlockInfo = docCopy.getReleaseVersionStatus() // 0 = gesperrt ('g') | 1 = freigegeben ('f')
|
|
|
|
if( lBlockInfo.equals("f") ) {
|
|
|
|
lReturn = docCopy.block(true, "d3groovy") // 1 = sperren
|
|
if (lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitProjektnummerID) ) {
|
|
if ( !doc.field[Const.gDDF_WEITAUFTRAGSNR][i].equals(docTemp.field[Const.gDDF_WEITAUFTRAGSNR][i]) && (!doc.field[Const.gDDF_WEITAUFTRAGSNR][i].equals("") && doc.field[Const.gDDF_WEITAUFTRAGSNR][i] != null) && !docType.getId().equals(Const.gDTS_DMEOP) && !docType.getId().equals(Const.gDTS_DOPPD) && !docType.getId().equals(Const.gDTS_DVERD) ) {
|
|
lProjNo = doc.field[Const.gDDF_WEITAUFTRAGSNR][i]
|
|
|
|
lProjNoOld = docTemp.field[Const.gDDF_WEITAUFTRAGSNR][i]
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
|
|
if( !lProjNoOld.equals("") ) {
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lProjNoOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '{doc.id()}%' OR pd.text like '%{doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Projektakte ${lProjNoOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
|
|
lReturn = docCopy.block(true ,"d3groovy") // 0 = entsperren 1 = sperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lProjNo}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Projektakte ${lProjNo}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
// 0 = gesperrt | 1 = freigegeben
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("g") ) {
|
|
lReturn = docCopy.block(false, "d3groovy") // 0 = entsperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Entsperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
createLinkFiles(d3, doc.id(), lOppNo, lProjNo, "", "", "", "", "", "")
|
|
}
|
|
|
|
} else if ( !doc.field[Const.gDDF_WEITAUFTRAGSNR][i].equals(docTemp.field[Const.gDDF_WEITAUFTRAGSNR][i]) && (doc.field[Const.gDDF_WEITAUFTRAGSNR][i].equals("") || doc.field[Const.gDDF_WEITAUFTRAGSNR][i] == null) && !docType.getId().equals(Const.gDTS_DMEOP) && !docType.getId().equals(Const.gDTS_DOPPD) && !docType.getId().equals(Const.gDTS_DVERD) ) {
|
|
|
|
// d3l sperren
|
|
// Sperrung der d3l Datei, wenn die Opportunity Nummer entfernt wird
|
|
lProjNo = doc.field[Const.gDDF_WEITAUFTRAGSNR][i]
|
|
|
|
lProjNoOld = docTemp.field[Const.gDDF_WEITAUFTRAGSNR][i]
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lProjNoOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Maschinenprojektakte ${lProjNoOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
|
|
lReturn = docCopy.block(true, "d3groovy") // 1 = sperren
|
|
if( lReturn != 0 ) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 13.07.2020: Ergänzung für den Service weitere BelegNr und weitere SrID
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitereBelegNrID) ) {
|
|
|
|
if ( !doc.field[Const.gDDF_WEITEREBELEGNR][i].equals(docTemp.field[Const.gDDF_WEITEREBELEGNR][i]) && (!doc.field[Const.gDDF_WEITEREBELEGNR][i].equals("") && doc.field[Const.gDDF_WEITEREBELEGNR][i] != null) ) {
|
|
|
|
def lBelegNo = doc.field[Const.gDDF_WEITEREBELEGNR][i]
|
|
def lBelegNoOld = docTemp.field[Const.gDDF_WEITEREBELEGNR][i]
|
|
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
|
|
if( lBelegNoOld != null && !lBelegNoOld.equals("") ) {
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${lBelegNoOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '{doc.id()}%' OR pd.text like '%{doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lBelegNoOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy");
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
lReturn = docCopy.block(true ,"d3groovy") // 0 = entsperren 1 = sperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${lBelegNo}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lBelegNo}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
// 0 = gesperrt | 1 = freigegeben
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("g") ) {
|
|
lReturn = docCopy.block(false, "d3groovy") // 0 = entsperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Entsperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
createLinkFilesService(d3, doc, lBelegNo, null);
|
|
}
|
|
|
|
} else if ( !doc.field[Const.gDDF_WEITEREBELEGNR][i].equals(docTemp.field[Const.gDDF_WEITEREBELEGNR][i]) && (doc.field[Const.gDDF_WEITEREBELEGNR][i].equals("") || doc.field[Const.gDDF_WEITEREBELEGNR][i] == null) ) {
|
|
|
|
// d3l sperren
|
|
// Sperrung der d3l Datei, wenn die Opportunity Nummer entfernt wird
|
|
def lBelegNo = doc.field[Const.gDDF_WEITEREBELEGNR][i]
|
|
def lBelegNoOld = docTemp.field[Const.gDDF_WEITEREBELEGNR][i]
|
|
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${lBelegNoOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
boolean belegNoExistsInOtherDocField = checkIfContentExistsInDoc(d3, doc, Const.gDDF_WEITEREBELEGNR, 0, lBelegNoOld);
|
|
if(belegNoExistsInOtherDocField == false) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lBelegNoOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
|
|
lReturn = docCopy.block(true, "d3groovy") // 1 = sperren
|
|
if( lReturn != 0 ) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitereSRIDID) ) {
|
|
|
|
if ( !doc.field[Const.gDDF_WEITERESRID][i].equals(docTemp.field[Const.gDDF_WEITERESRID][i]) && (!doc.field[Const.gDDF_WEITERESRID][i].equals("") && doc.field[Const.gDDF_WEITERESRID][i] != null) ) {
|
|
|
|
def lSrIdNo = doc.field[Const.gDDF_WEITERESRID][i]
|
|
def lSrIdOld = docTemp.field[Const.gDDF_WEITERESRID][i]
|
|
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
|
|
if( lSrIdOld != null && !lSrIdOld.equals("") ) {
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_SRID} = '${lSrIdOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lSrIdOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
|
|
lReturn = docCopy.block(true ,"d3groovy") // 0 = entsperren 1 = sperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_SRID} = '${lSrIdNo}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lSrIdNo}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
// 0 = gesperrt | 1 = freigegeben
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("g") ) {
|
|
lReturn = docCopy.block(false, "d3groovy") // 0 = entsperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Entsperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
createLinkFilesService(d3, doc, null, lSrIdNo);
|
|
}
|
|
|
|
} else if ( !doc.field[Const.gDDF_WEITERESRID][i].equals(docTemp.field[Const.gDDF_WEITERESRID][i]) && (doc.field[Const.gDDF_WEITERESRID][i].equals("") || doc.field[Const.gDDF_WEITERESRID][i] == null) ) {
|
|
|
|
// d3l sperren
|
|
// Sperrung der d3l Datei, wenn die Opportunity Nummer entfernt wird
|
|
def lSrIdNo = doc.field[Const.gDDF_WEITERESRID][i]
|
|
def lSrIdOld = docTemp.field[Const.gDDF_WEITERESRID][i]
|
|
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_SRID} = '${lSrIdOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
boolean srIdExistsInOtherDocField = checkIfContentExistsInDoc(d3, doc, Const.gDDF_WEITERESRID, 0, lSrIdOld);
|
|
if(srIdExistsInOtherDocField == false) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lSrIdOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
|
|
lReturn = docCopy.block(true, "d3groovy") // 1 = sperren
|
|
if( lReturn != 0 ) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// imue 26.08.20.20: Ergänzung für Equipment
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitereEquipmentID) ) {
|
|
|
|
if ( ( doc.field[Const.gDDF_WEITEREEQUIPMENT][i] != null && !doc.field[Const.gDDF_WEITEREEQUIPMENT][i].equals("") ) && !doc.field[Const.gDDF_WEITEREEQUIPMENT][i].equals(docTemp.field[Const.gDDF_WEITEREEQUIPMENT][i]) ) {
|
|
|
|
def lEquipmentNo = doc.field[Const.gDDF_WEITEREEQUIPMENT][i]
|
|
def lEquipmentNoOld = docTemp.field[Const.gDDF_WEITEREEQUIPMENT][i]
|
|
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
|
|
if( lEquipmentNoOld != null && !lEquipmentNoOld.equals("") ) {
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${lEquipmentNoOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lEquipmentNoOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy");
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
lReturn = docCopy.block(true ,"d3groovy") // 0 = entsperren 1 = sperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${lEquipmentNo}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lEquipmentNo}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
// 0 = gesperrt | 1 = freigegeben
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("g") ) {
|
|
lReturn = docCopy.block(false, "d3groovy") // 0 = entsperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Entsperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
createLinkFilesEquipment(d3, doc, lEquipmentNo);
|
|
}
|
|
|
|
} else if ( ( doc.field[Const.gDDF_WEITEREEQUIPMENT][i] == null || doc.field[Const.gDDF_WEITEREEQUIPMENT][i].equals("") ) && !doc.field[Const.gDDF_WEITEREEQUIPMENT][i].equals(docTemp.field[Const.gDDF_WEITEREEQUIPMENT][i]) ) {
|
|
|
|
// d3l sperren
|
|
// Sperrung der d3l Datei, wenn die Opportunity Nummer entfernt wird
|
|
def lEquipmentNo = doc.field[Const.gDDF_WEITEREEQUIPMENT][i]
|
|
def lEquipmentNoOld = docTemp.field[Const.gDDF_WEITEREEQUIPMENT][i]
|
|
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${lEquipmentNoOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
boolean equipmentNoExistsInOtherDocField = checkIfContentExistsInDoc(d3, doc, Const.gDDF_WEITEREBELEGNR, 0, lEquipmentNoOld);
|
|
if(equipmentNoExistsInOtherDocField == false) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lEquipmentNoOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
|
|
lReturn = docCopy.block(true, "d3groovy") // 1 = sperren
|
|
if( lReturn != 0 ) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 05.05.2022: Ergänzung für den Einkauf weitere BelegNr
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitereEinkaufBelegNrID) ) {
|
|
|
|
if ( !doc.field[Const.gDDF_WEITEREBELEGNR][i].equals(docTemp.field[Const.gDDF_WEITEREBELEGNR][i]) && (!doc.field[Const.gDDF_WEITEREBELEGNR][i].equals("") && doc.field[Const.gDDF_WEITEREBELEGNR][i] != null) ) {
|
|
|
|
def lBelegNo = doc.field[Const.gDDF_WEITEREBELEGNR][i]
|
|
def lBelegNoOld = docTemp.field[Const.gDDF_WEITEREBELEGNR][i]
|
|
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
|
|
if( lBelegNoOld != null && !lBelegNoOld.equals("") ) {
|
|
// Alte Nummer überprüfen und d3l ggf. sperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${lBelegNoOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '{doc.id()}%' OR pd.text like '%{doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lBelegNoOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy");
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
lReturn = docCopy.block(true ,"d3groovy") // 0 = entsperren 1 = sperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Neue Nummer überprüfen und ggf. d3l erstellen, falls vorhanden d3l entsperren
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${lBelegNo}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lBelegNo}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
// 0 = gesperrt | 1 = freigegeben
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("g") ) {
|
|
lReturn = docCopy.block(false, "d3groovy") // 0 = entsperren
|
|
if(lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Entsperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
createLinkFilesPurchase(d3, doc, lBelegNo);
|
|
}
|
|
|
|
} else if ( !doc.field[Const.gDDF_WEITEREBELEGNR][i].equals(docTemp.field[Const.gDDF_WEITEREBELEGNR][i]) && (doc.field[Const.gDDF_WEITEREBELEGNR][i].equals("") || doc.field[Const.gDDF_WEITEREBELEGNR][i] == null) ) {
|
|
|
|
// d3l sperren
|
|
// Sperrung der d3l Datei, wenn die Opportunity Nummer entfernt wird
|
|
def lBelegNo = doc.field[Const.gDDF_WEITEREBELEGNR][i]
|
|
def lBelegNoOld = docTemp.field[Const.gDDF_WEITEREBELEGNR][i]
|
|
|
|
def sqlStatement = "SELECT fs.doku_id as lCopyDokID " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${lBelegNoOld}' " +
|
|
"AND ( pd.text like '%${doc.id()}%' OR pd.text like '${doc.id()}%' OR pd.text like '%${doc.id()}' ) " +
|
|
"AND ( pd.datei_erw = 'D3L' OR pd.datei_erw = 'd3l' ) " +
|
|
"AND fs.kue_dokuart = '${docType.getId()}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lCopyCount = sqlResult.size()
|
|
lCopyDokID = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lCopyDokID.add(grr.get("lCopyDokID"))
|
|
}
|
|
|
|
if( lCopyCount != 0 ) {
|
|
boolean belegNoExistsInOtherDocField = checkIfContentExistsInDoc(d3, doc, Const.gDDF_WEITEREBELEGNR, 0, lBelegNoOld);
|
|
if(belegNoExistsInOtherDocField == false) {
|
|
d3.log.info("Die Kopie des Dokuments ${doc.id()} existiert bereits in der Akte ${lBelegNoOld}!")
|
|
for(int lCount=0; lCount < lCopyCount; lCount++) {
|
|
Document docCopy = d3.archive.getDocument(lCopyDokID.get(lCount), "d3groovy")
|
|
|
|
lBlockInfo = docCopy.getReleaseVersionStatus()
|
|
if( lBlockInfo.equals("f") ) {
|
|
|
|
lReturn = docCopy.block(true, "d3groovy") // 1 = sperren
|
|
if( lReturn != 0 ) {
|
|
d3.log.error("Das Dokument ${lCopyDokID.get(lCount)} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Überprüfung ob der Wert null ist
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return wenn null, dann Rückgabe von "", ansonsten Originalwert
|
|
*/
|
|
public static String checkIfNullValue(String docValue) {
|
|
if(docValue == null || docValue.equals("null") || docValue.equals("")) {
|
|
return "";
|
|
} else {
|
|
return docValue;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Überprüfung ob der Wert null ist oder spezielle Zeichen enthält, notwendig für JPL Dateien
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return wenn null, dann Rückgabe von "", ansonsten Originalwert mit maskierten Sonderzeichen
|
|
*/
|
|
public static String checkValueForJpl(String docValue) {
|
|
if(docValue == null || docValue.equals("null") || docValue.equals("")) {
|
|
return "";
|
|
} else {
|
|
String docValueMasked = checkSpecialCharsInString(docValue);
|
|
if(docValueMasked != null && !docValueMasked.equals(docValue)) {
|
|
return docValueMasked;
|
|
} else {
|
|
return docValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Überprüfung ob die Eigenschaft (Repository-ID) in der Dokumentart vorhanden ist
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return true=vorhanden; false=nicht vorhanden
|
|
*/
|
|
public static boolean checkIfRepoIDExistsInDocType(D3Interface d3, DocumentType docType, int repoID) {
|
|
|
|
// Ermittlung in welchen Dokumentarten die Eigenschaft Opportunitynummer, Hauptopportunity, Submission vorkommt
|
|
// Globale Liste als Cache hinzugefügt
|
|
if(docType != null) {
|
|
|
|
// Prüfen, ob die Kombination bereits in der Liste enthalten ist:
|
|
def ergebnis = RepoInDocTypeList.get( docType.id() + Integer.toString(repoID) );
|
|
|
|
//d3.log.error( "checkIfRepoIDExistsInDocType => ${ergebnis} ");
|
|
|
|
if ( ergebnis == null )
|
|
{
|
|
def sqlStatement = "SELECT DISTINCT kue_dokuart as dokuArt " +
|
|
"FROM fispe_titel_dokuart " +
|
|
"WHERE repository_id = '${Integer.toString(repoID)}' " +
|
|
"AND kue_dokuart = '${docType.id()}'";
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
|
|
if ( sqlResult != null && sqlResult.size() > 0 )
|
|
{
|
|
//d3.log.error( "hinzugefügt: " + docType.id() + " / ${Integer.toString(repoID)} / true " );
|
|
RepoInDocTypeList.put( docType.id() + Integer.toString(repoID), true );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
//d3.log.error( "hinzugefügt: " + docType.id() + " / ${Integer.toString(repoID)} / false " );
|
|
RepoInDocTypeList.put( docType.id() + Integer.toString(repoID), false );
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//d3.log.error( "gefunden: ${docType.id()} / ${Integer.toString(repoID)} / ${ergebnis} " );
|
|
return ergebnis;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Überprüfung ob ein Eigenschaftswert im 60er Feld eingetragen wurde
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return true=vorhanden; false=nicht vorhanden
|
|
*/
|
|
public static boolean checkIfContentExistsInDoc(D3Interface d3, Document doc, int ddfToCheck, int posToSkip, String valueToCheck) {
|
|
d3.log.info("Start Functions checkIfContentExistsInDoc");
|
|
|
|
for(int i=1; i<=Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if(i != posToSkip) {
|
|
if(doc.field[ddfToCheck][i] != null) {
|
|
String currentValue = doc.field[ddfToCheck][i];
|
|
if(currentValue.equals(valueToCheck)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Überprüfung ob sich ein Eigenschaftsfeld geändert hat
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return true=geändert; false=nicht geändert
|
|
*/
|
|
public static boolean checkIfValueChanged(D3Interface d3, Document doc, Document gOldDoc, int ddfToCheck) {
|
|
d3.log.info("Start Functions checkIfValueChanged");
|
|
if(gOldDoc != null) {
|
|
if(ddfToCheck >= 60 && ddfToCheck <=69) {
|
|
// Mehrfachfeld
|
|
for(int i=1; i<=Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if(doc.field[ddfToCheck][i] == null && gOldDoc.field[ddfToCheck][i] != null) {
|
|
d3.log.info("End Functions checkIfValueChanged = true");
|
|
return true;
|
|
} else if(doc.field[ddfToCheck][i] != null && gOldDoc.field[ddfToCheck][i] == null) {
|
|
d3.log.info("End Functions checkIfValueChanged = true");
|
|
return true;
|
|
} else if(doc.field[ddfToCheck][i] != null && gOldDoc.field[ddfToCheck][i] != null) {
|
|
if(doc.field[ddfToCheck][i] != gOldDoc.field[ddfToCheck][i] ) {
|
|
d3.log.info("End Functions checkIfValueChanged = true");
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Einfachfeld
|
|
if(doc.field[ddfToCheck] == null && gOldDoc.field[ddfToCheck] != null) {
|
|
d3.log.info("End Functions checkIfValueChanged = true");
|
|
return true;
|
|
} else if(doc.field[ddfToCheck] != null && gOldDoc.field[ddfToCheck] == null) {
|
|
d3.log.info("End Functions checkIfValueChanged = true");
|
|
return true;
|
|
} else if(doc.field[ddfToCheck] != null && gOldDoc.field[ddfToCheck] != null) {
|
|
if(doc.field[ddfToCheck] != gOldDoc.field[ddfToCheck]) {
|
|
d3.log.info("End Functions checkIfValueChanged = true");
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
d3.log.info("End Functions checkIfValueChanged = false");
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Prüft ob ein Wert nicht doppelt eingetragen wurde im Service (Weitere BelegNr oder Weitere SrId)
|
|
* @author Service
|
|
* @see UpdateAttributeEntry, NewVersionEntry, InsertEntry
|
|
* @return Rückgabe 0 wenn erfolgreich; Rückgabe Zeilennummer wenn nicht erfolgreich
|
|
*/
|
|
public static int checkServiceNr(D3Interface d3, Document doc, int repoId) {
|
|
d3.log.info("Start Functions checkServiceNr");
|
|
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), repoId) ){
|
|
if( repoId == SystemSpecificConst.gWeitereBelegNrID ) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
def lBelegNr = doc.field[Const.gDDF_WEITEREBELEGNR][i];
|
|
if(lBelegNr != null) {
|
|
boolean valueIsNotSingle = checkIfContentExistsInDoc(d3, doc, Const.gDDF_WEITEREBELEGNR, i, lBelegNr);
|
|
if(valueIsNotSingle == true) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
} else if( repoId == SystemSpecificConst.gWeitereSRIDID ) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
def lSrId = doc.field[Const.gDDF_WEITERESRID][i];
|
|
if(lSrId != null) {
|
|
boolean valueIsNotSingle = checkIfContentExistsInDoc(d3, doc, Const.gDDF_WEITERESRID, i, lSrId);
|
|
if(valueIsNotSingle == true) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Prüft ob ein Wert nicht doppelt eingetragen wurde im Einkauf (Weitere BelegNrd)
|
|
* @author Einkauf
|
|
* @see UpdateAttributeEntry, NewVersionEntry, InsertEntry
|
|
* @return Rückgabe 0 wenn erfolgreich; Rückgabe Zeilennummer wenn nicht erfolgreich
|
|
*/
|
|
public static int checkPurchaseNr(D3Interface d3, Document doc, int repoId) {
|
|
d3.log.info("Start Functions checkPurchaseNr");
|
|
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), repoId) ){
|
|
if( repoId == SystemSpecificConst.gWeitereEinkaufBelegNrID ) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
def lBelegNr = doc.field[Const.gDDF_WEITEREBELEGNR][i];
|
|
if(lBelegNr != null) {
|
|
boolean valueIsNotSingle = checkIfContentExistsInDoc(d3, doc, Const.gDDF_WEITEREBELEGNR, i, lBelegNr);
|
|
if(valueIsNotSingle == true) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Überprüfung ob sich ein Sonderzeichen im String befindet (notwendig für JPL Dateien und dem Hostimport)
|
|
* Folgende Zeichen sind nicht möglich: ":", """ ,da sie von JPL mit Funktionen vorbelegt sind
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return String mit maskierten Sonderzeichen
|
|
*/
|
|
public static String checkSpecialCharsInString(String stringToCheck) {
|
|
final List<String> metaCharacters = new ArrayList<>();
|
|
metaCharacters.add("\\");
|
|
metaCharacters.add("'");
|
|
for(String currentCharacter : metaCharacters) {
|
|
if(stringToCheck.contains(currentCharacter)) {
|
|
stringToCheck = stringToCheck.replace(currentCharacter,"\\"+currentCharacter);
|
|
}
|
|
}
|
|
return stringToCheck;
|
|
}
|
|
|
|
/**
|
|
* Wenn Sender in der Administrativen Domänen Akte zu finden ist, dann Kommuniaktionsrichtung "innerhalb Optima", wenn NICHT dann "eingehend".
|
|
* Danach folgt die Prüfung des Empfänger, wenn dieser sich NICHT in der Administrativen Domänen Akte befindet, ändert sich die Kommuniaktionsrichtung auf "ausgend".
|
|
* Je nach Kommunikationsrichtung wird infolgedessen die "Abteilung Sender" gefüllt aus den Benutzerinformationen.
|
|
* Voraussetzung: Der Absender steht mit seiner E-Mail-Adresse ebenfalls initial in der Kommunikationsrichtung drin.
|
|
* @author Übergreifende Prozesse
|
|
* @see InsertEntry
|
|
* @return keine Rückgabe, im Hintergrund wird die "Kommunikationsrichtigung" und der "Abteilung Sender" gefüllt
|
|
*/
|
|
public static int checkMailProperties(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions checkMailProperties");
|
|
|
|
def lRetCode
|
|
|
|
// 23.06.2015 - tbur - Splitten des Attributs Kommunikationsrichtung.
|
|
// Aus SMOL kommt hier die E-Mailadresse des Absenders. Wenn diese die Domain OPTIMA-GROUP.COM enthält, dann
|
|
// handelt es sich um eine ausgehende Mail. In diesem Fall wird der Wert in "ausgehend" geändert.
|
|
// Ansonsten wird es in "eingehend" geändert.
|
|
if( ( doc.field[Const.gDDF_KOMMRICHTUNG] != null && !doc.field[Const.gDDF_KOMMRICHTUNG].equals("eingehend")
|
|
&& !doc.field[Const.gDDF_KOMMRICHTUNG].equals("ausgehend") && !doc.field[Const.gDDF_KOMMRICHTUNG].equals("intern (innerhalb OPTIMA Group)") )
|
|
&& checkIfRepoIDExistsInDocType(d3, docType, SystemSpecificConst.gKommunikationsrichtID)) {
|
|
|
|
def domain
|
|
def sender
|
|
def receiver
|
|
def cnt_contact
|
|
def cnt_receiver
|
|
def startIndexDomainSender
|
|
List<String> domainsSender = new ArrayList<>()
|
|
def startIndexDomainEmpf
|
|
List<String> domainsEmpf = new ArrayList<>()
|
|
// 31.07.2017 sm_n_num_occurs("dok_dat_feld_:gDDF_EMAILKONTAKT") statt CUR_60_FIELDS
|
|
// 23.07.2019 imue anscheinend nicht mehr in Verwendung -> cnt_contact = sm_n_num_occurs("dok_dat_feld_:gDDF_EMAILKONTAKT")
|
|
sender = doc.field[Const.gDDF_KOMMRICHTUNG]
|
|
if( sender != null ) {
|
|
String convertedString = sender.toLowerCase()
|
|
domain = convertedString
|
|
}
|
|
if(domain != null) {
|
|
// 23.07.2019 imue - Ergänzung um weitere Domänen siehe OPG-2159
|
|
startIndexDomainSender = domain.indexOf("@")
|
|
domain = domain.substring(startIndexDomainSender + 1)
|
|
def sqlStatementDom = "SELECT dok_dat_feld_${Const.gDDF_DOMAIN} as domainsSender " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_DOMAIN} = '${domain}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AADOM}' "
|
|
List<GroovyRowResult> sqlResultDom = d3.sql.executeAndGet(sqlStatementDom);
|
|
if(sqlResultDom != null) {
|
|
lRetCode = sqlResultDom.size()
|
|
for(GroovyRowResult grr : sqlResultDom) {
|
|
domainsSender.add(grr.get("domainsSender"))
|
|
}
|
|
}
|
|
}
|
|
domain = lRetCode
|
|
if( domain > 0 ) {
|
|
doc.field[Const.gDDF_KOMMRICHTUNG] = "intern (innerhalb OPTIMA Group)"
|
|
for( int a=1; a < Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); a++) {
|
|
String convertedString = doc.field[Const.gDDF_EMPFAENGERM][a];
|
|
if(convertedString != null) {
|
|
convertedString = convertedString.toLowerCase();
|
|
receiver = convertedString
|
|
d3.log.info(" Empfänger :a = " + receiver)
|
|
if(receiver != null) {
|
|
// 23.07.2019 imue - Ergänzung um weitere Domänen siehe OPG-2159
|
|
startIndexDomainEmpf = receiver.indexOf("@")
|
|
receiver = receiver.substring(startIndexDomainEmpf + 1)
|
|
def sqlStatementDomEmpf = "SELECT dok_dat_feld_${Const.gDDF_DOMAIN} as domainsEmpf " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_DOMAIN} = '${receiver}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AADOM}' "
|
|
List<GroovyRowResult> sqlResultDomEmpf = d3.sql.executeAndGet(sqlStatementDomEmpf);
|
|
if(sqlResultDomEmpf != null) {
|
|
lRetCode = sqlResultDomEmpf.size()
|
|
for(GroovyRowResult grr : sqlResultDomEmpf) {
|
|
domainsEmpf.add(grr.get("domainsEmpf"))
|
|
}
|
|
d3.log.info(" Anzahl OPTIMA in Empfänger ${a} = ${lRetCode}" )
|
|
if(lRetCode == 0) {
|
|
doc.field[Const.gDDF_KOMMRICHTUNG] = "ausgehend"
|
|
d3.log.info(" Kommunikationsrichtung in ausgehend geändert" )
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Wenn der EMpfängerkreis auch nur OPTIMA enthält, dann ist die Richtung INTERN
|
|
} else {
|
|
doc.field[Const.gDDF_KOMMRICHTUNG] = "eingehend"
|
|
// Bei eingehenden Mails muss der Absender in das Feld E-Mail Kontakt geschrieben werden
|
|
}
|
|
// d3.log.info(" Richtung = " + doc.field[Const.gDDF_KOMMRICHTUNG])
|
|
}
|
|
|
|
// 17.12.2015 - tbur - Füllen der Attribute Abteilung Sender und Abteilung Empfänger.
|
|
// Mit den Sender- bzw- Empfängeremailadressen soll die Abteilung aus dem Benutzerstamm
|
|
// ermittelt werden.
|
|
if( ( doc.field[Const.gDDF_KOMMRICHTUNG] != null ) && checkIfRepoIDExistsInDocType(d3, docType, SystemSpecificConst.gKommunikationsrichtID) ) {
|
|
def sender
|
|
def abteilung
|
|
def chk_receiver = 0
|
|
def chk_sender = 0
|
|
def cnt_receiver
|
|
def receiver
|
|
if( doc.field[Const.gDDF_KOMMRICHTUNG].equals("intern (innerhalb OPTIMA Group)") ) {
|
|
chk_receiver = 1
|
|
chk_sender = 1
|
|
d3.log.info(" intern = Sender und Empfänger werden bearbeitet.")
|
|
} else if( doc.field[Const.gDDF_KOMMRICHTUNG].equals("ausgehend") ) {
|
|
chk_receiver = 0
|
|
chk_sender = 1
|
|
d3.log.info(" ausgehend = Nur Sender wird bearbeitet.")
|
|
} else if( doc.field[Const.gDDF_KOMMRICHTUNG].equals("eingehend") ) {
|
|
chk_receiver = 1
|
|
chk_sender = 0
|
|
d3.log.info(" eingehend = nichts wird bearbeitet.")
|
|
} else {
|
|
chk_receiver = 0
|
|
chk_sender = 0
|
|
d3.log.info(" FEHLER KommRichtung = " + doc.field[Const.gDDF_KOMMRICHTUNG])
|
|
}
|
|
// Prüfen des Senders
|
|
if( chk_sender == 1 ) {
|
|
sender = doc.field[Const.gDDF_SENDER]
|
|
if( sender != null ) {
|
|
String convertedString = sender.toUpperCase()
|
|
sender = convertedString
|
|
}
|
|
d3.log.info(" Sender = " + sender)
|
|
if( sender != null && !docType.getId().equals(Const.gDTS_DPROO) ) {
|
|
def sqlStatementAbt = "SELECT abteilung as abteilung FROM benutzer WHERE upper(email) = '${sender}' "
|
|
List<GroovyRowResult> sqlResultAbt = d3.sql.executeAndGet(sqlStatementAbt);
|
|
if(sqlResultAbt != null && sqlResultAbt.size() > 0) {
|
|
abteilung = sqlResultAbt.getAt(0).get("abteilung")
|
|
if( abteilung != null && !abteilung.equals("") ) {
|
|
d3.log.info(" Abteilung = " + abteilung)
|
|
doc.field[Const.gDDF_ABTSENDER] = abteilung
|
|
} else {
|
|
d3.log.info(" Keine Abteilung gefunden")
|
|
doc.field[Const.gDDF_ABTSENDER] = "Keine Abteilung gefunden"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Prüfen der Empfänger
|
|
if( chk_receiver == 1 ) {
|
|
for( int a=1; a <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); a++ ) {
|
|
receiver = doc.field[Const.gDDF_EMPFAENGERM][a]
|
|
if( receiver != null ) {
|
|
String convertedString = doc.field[Const.gDDF_EMPFAENGERM][a].toUpperCase()
|
|
receiver = convertedString
|
|
d3.log.info(" Empfänger ${a} = " + receiver)
|
|
def sqlStatementAbt = "SELECT abteilung as abteilung FROM benutzer WHERE upper(email) = '${receiver}' "
|
|
List<GroovyRowResult> sqlResultAbt = d3.sql.executeAndGet(sqlStatementAbt);
|
|
if( sqlResultAbt != null && sqlResultAbt.size() > 0 ) {
|
|
abteilung = sqlResultAbt.getAt(0).get("abteilung")
|
|
doc.field[Const.gDDF_ABTEMPM][a] = abteilung
|
|
d3.log.info(" dok_dat_feld_" + Const.gDDF_ABTEMPM + "[${a}] = " + abteilung )
|
|
}
|
|
} else {
|
|
d3.log.info(" Keine Abteilung gefunden")
|
|
doc.field[Const.gDDF_ABTEMPM][a] = "Keine Abteilung gefunden"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Erstellung der Aktenstruktur für die Baudokumente
|
|
* @author Unterstützende Prozesse
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund werden Akten erstellt
|
|
*/
|
|
public static void createConstDocFolder(D3Interface d3, Document doc, def lBauprojekt) {
|
|
d3.log.info("Start Functions createConstDocFolder");
|
|
|
|
def lReturnvalue //Fehlercode
|
|
|
|
//Setzen der Attributwerte für die Baugruppe-Akten
|
|
Document newDoc = d3.archive.newDocument()
|
|
newDoc.status = Document.DocStatus.DOC_STAT_RELEASE
|
|
newDoc.field[Const.gDDF_BAUPROJEKT] = lBauprojekt
|
|
newDoc.field[Const.gDDF_PROZESS] = "PZ003"
|
|
newDoc.type = Const.gDTS_ABAUK
|
|
|
|
//Definition der Bauakten
|
|
String[] lBauakten = [
|
|
"01 Besprechungen",
|
|
"02 Controlling",
|
|
"03 Zeitplan",
|
|
"04 Gebäudepläne",
|
|
"05 Vorplanungen",
|
|
"06 Genehmigungen",
|
|
"07 Ausführungen",
|
|
"08 Ausschreibungen I Beschaffungen",
|
|
"09 Abnahmen",
|
|
"10 Reparaturen I Reklamationen",
|
|
"11 Keine Ahnung wo das hin muss"
|
|
]
|
|
def lAnz = lBauakten.size()
|
|
|
|
for(int j=0; j < lAnz; j++) {
|
|
newDoc.field[Const.gDDF_BAUAKTE] = lBauakten[j]
|
|
lReturnvalue = d3.call.folder_create(newDoc)
|
|
if (lReturnvalue != 0) {
|
|
d3.log.error("### Fehler Anlage Bauakte - folder_create (createConstDocFolder) ${lReturnvalue}")
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Organisation D3L-Dateien "Kundenkontaktdokumente"
|
|
* @author Maschinenprojekt
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund werden D3L-Dateien erstellt
|
|
*/
|
|
public static void createD3lForDKUKO(D3Interface d3, Document doc, def ln15 ) {
|
|
d3.log.info("Start Functions createD3lForDKUKO");
|
|
|
|
// Suche alle Kundenkontaktdokument "DKUKO" mit der gleichen Kundenkontakt-ID DDF15 deren Fileextension != d3l
|
|
d3.log.info("createD3lForDKUKO gestartet für " + doc.id());
|
|
|
|
def lDKUKOCount
|
|
def lReturn
|
|
def ln60Count
|
|
def ln63Count
|
|
def ln65Count
|
|
def ln68Count
|
|
def lDocCount
|
|
def lCount
|
|
def lDateTime
|
|
def l60sCount
|
|
def ln4
|
|
|
|
def sqlStatement = "SELECT p.doku_id as lDKUKODocID " +
|
|
"FROM firmen_spezifisch as f, phys_datei as p " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_KONTAKTNUMMER} = '${ln15}' " +
|
|
"AND p.datei_erw <> 'D3L' " +
|
|
"AND p.dokuart = '${Const.gDTS_DKUKO}' " +
|
|
"AND p.doku_id = f.doku_id ";
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null && sqlResult.size() > 0) {
|
|
lDKUKOCount = sqlResult.size()
|
|
|
|
d3.log.info("createD3lForDKUKO - doc ${doc.id()} / Kontaktnummer ${ln15} / DKUKO Anzahl ${sqlResult.size()}");
|
|
|
|
for(int i=0; i < lDKUKOCount; i++) {
|
|
|
|
def sqlStatement1 = "SELECT dok_dat_feld_${Const.gDDF_ABTSENDER} as ln6, " +
|
|
"dok_dat_feld_${Const.gDDF_SENDER} as ln7, " +
|
|
"dok_dat_feld_${Const.gDDF_PROJKLAMMER} as ln8, " +
|
|
"dok_dat_feld_${Const.gDDF_RESPSALESMAN} as ln14, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKTITLE} as ln17, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKGROUP} as ln21, " +
|
|
"dok_dat_feld_${Const.gDDF_KDAKTNAME} as ln24, " +
|
|
"dok_dat_feld_${Const.gDDF_KOMMRICHTUNG} as ln32, " +
|
|
"dok_dat_feld_${Const.gDDF_JAHR} as ln33, " +
|
|
"dok_dat_feld_${Const.gDDF_MONAT} as ln34, " +
|
|
"dok_dat_feld_${Const.gDDF_VKPHASE} as ln35, " +
|
|
"dok_dat_feld_${Const.gDDF_ERGEBNISDOK} as ln44, " +
|
|
"dok_dat_feld_${Const.gDDF_KDAKTKAT} as ln45, " +
|
|
"dok_dat_feld_${Const.gDDF_ARCDOCID} as ln49, " +
|
|
"dok_dat_feld_${Const.gDDF_ERDATE} as ln50, " +
|
|
"dok_dat_feld_${Const.gDDF_KONTAKTDATE} as ln52, " +
|
|
"dok_dat_feld_${Const.gDDF_DOCINFONR} as ln80 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE doku_id = '${sqlResult.getAt(i).get("lDKUKODocID")}'";
|
|
|
|
List<GroovyRowResult> sqlResult1 = d3.sql.executeAndGet(sqlStatement1);
|
|
if(sqlResult1 != null && sqlResult1.size() > 0) {
|
|
|
|
def ln6 = sqlResult1.getAt(0).get("ln6")
|
|
def ln7 = sqlResult1.getAt(0).get("ln7")
|
|
def ln8 = sqlResult1.getAt(0).get("ln8")
|
|
def ln14 = sqlResult1.getAt(0).get("ln14")
|
|
def ln17 = sqlResult1.getAt(0).get("ln17")
|
|
def ln21 = sqlResult1.getAt(0).get("ln21")
|
|
def ln24 = sqlResult1.getAt(0).get("ln24")
|
|
def ln32 = sqlResult1.getAt(0).get("ln32")
|
|
def ln33 = sqlResult1.getAt(0).get("ln33")
|
|
def ln34 = sqlResult1.getAt(0).get("ln34")
|
|
def ln35 = sqlResult1.getAt(0).get("ln35")
|
|
def ln44 = sqlResult1.getAt(0).get("ln44")
|
|
def ln45 = sqlResult1.getAt(0).get("ln45")
|
|
def ln49 = sqlResult1.getAt(0).get("ln49")
|
|
def ln50 = sqlResult1.getAt(0).get("ln50")
|
|
def ln52 = sqlResult1.getAt(0).get("ln52")
|
|
def ln80 = sqlResult1.getAt(0).get("ln80")
|
|
|
|
def sqlStatement2 = "SELECT dok_dat_feld_${Const.gDDF_STATUS} as ln1, " +
|
|
"dok_dat_feld_${Const.gDDF_PROZESS} as ln5, " +
|
|
"dok_dat_feld_${Const.gDDF_AUFTRNR} as ln19, " +
|
|
"dok_dat_feld_${Const.gDDF_KNR} as ln22, " +
|
|
"dok_dat_feld_${Const.gDDF_KNAME} as ln23, " +
|
|
"dok_dat_feld_${Const.gDDF_BUCHKREIS} as ln28, " +
|
|
"dok_dat_feld_${Const.gDDF_OPPNUMMER} as ln31, " +
|
|
"dok_dat_feld_${Const.gDDF_HAUPTOPP} as ln36, " +
|
|
"dok_dat_feld_${Const.gDDF_SUBMISSION} as ln37, " +
|
|
"dok_dat_feld_${Const.gDFF_ABTEILUNG} as ln39, " +
|
|
"dok_dat_feld_${Const.gDDF_SALESGROUP} as ln47 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE doku_id = '${doc.id()}' ";
|
|
|
|
List<GroovyRowResult> sqlResult2 = d3.sql.executeAndGet(sqlStatement2);
|
|
if(sqlResult2 != null && sqlResult2.size() > 0) {
|
|
|
|
def ln1 = sqlResult2.getAt(0).get("ln1")
|
|
def ln5 = sqlResult2.getAt(0).get("ln5")
|
|
def ln19 = sqlResult2.getAt(0).get("ln19")
|
|
def ln22 = sqlResult2.getAt(0).get("ln22")
|
|
def ln23 = sqlResult2.getAt(0).get("ln23")
|
|
def ln28 = sqlResult2.getAt(0).get("ln28")
|
|
def ln31 = sqlResult2.getAt(0).get("ln31")
|
|
def ln36 = sqlResult2.getAt(0).get("ln36")
|
|
def ln37 = sqlResult2.getAt(0).get("ln37")
|
|
def ln39 = sqlResult2.getAt(0).get("ln39")
|
|
def ln47 = sqlResult2.getAt(0).get("ln47")
|
|
|
|
List<String> ln60 = new ArrayList<>();
|
|
def sqlStatement3 = "SELECT value_char as ln60 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${sqlResult.getAt(i).get("lDKUKODocID")}' " +
|
|
"AND field_no = '${Const.gDDF_ERGDOCFUER}'"
|
|
List<GroovyRowResult> sqlResult3 = d3.sql.executeAndGet(sqlStatement3);
|
|
if(sqlResult3 != null && sqlResult3.size() > 0) {
|
|
for(GroovyRowResult grr : sqlResult3) {
|
|
ln60.add(grr.get("ln60"));
|
|
}
|
|
}
|
|
|
|
List<String> ln63 = new ArrayList<>();
|
|
def sqlStatement4 = "SELECT value_char as ln63 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${sqlResult.getAt(i).get("lDKUKODocID")}' " +
|
|
"AND field_no = '${Const.gDDF_ABTEMPM}' "
|
|
List<GroovyRowResult> sqlResult4 = d3.sql.executeAndGet(sqlStatement4);
|
|
if(sqlResult4 != null && sqlResult4.size() > 0) {
|
|
for(GroovyRowResult grr : sqlResult4) {
|
|
ln63.add(grr.get("ln63"))
|
|
}
|
|
}
|
|
|
|
List<String> ln65 = new ArrayList<>();
|
|
def sqlStatement5 = "SELECT value_char as ln65 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${sqlResult.getAt(i).get("lDKUKODocID")}' " +
|
|
"AND field_no = '${Const.gDDF_EMPFAENGERM}'"
|
|
List<GroovyRowResult> sqlResult5 = d3.sql.executeAndGet(sqlStatement5);
|
|
if(sqlResult5 != null && sqlResult5.size() > 0) {
|
|
for(GroovyRowResult grr : sqlResult5) {
|
|
ln65.add(grr.get("ln65"))
|
|
}
|
|
}
|
|
|
|
List<String> ln68 = new ArrayList<>();
|
|
def sqlStatement6 = "SELECT value_char as ln68 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${doc.id()}' " +
|
|
"AND field_no = '${Const.gDDF_BUCHKREIS68}' "
|
|
List<GroovyRowResult> sqlResult6 = d3.sql.executeAndGet(sqlStatement6);
|
|
if(sqlResult6 != null && sqlResult6.size() > 0) {
|
|
for(GroovyRowResult grr : sqlResult6) {
|
|
ln68.add(grr.get("ln68"))
|
|
}
|
|
}
|
|
|
|
Date dateLog = new Date();
|
|
SimpleDateFormat sdfLog = new SimpleDateFormat("yyyyMMddHHmmssSSS");
|
|
String dateString = sdfLog.format(dateLog);
|
|
|
|
File lPathD3L = new File("F:\\d3\\Hostimport\\CopyDKUKO\\" + sqlResult.getAt(i).get("lDKUKODocID") + "_" + dateString + "_" + ln15 + ".D3L");
|
|
File lPathJPL = new File("F:\\d3\\Hostimport\\CopyDKUKO\\"+ sqlResult.getAt(i).get("lDKUKODocID") + "_" + dateString + "_" + ln15 + ".jpl");
|
|
|
|
lPathJPL.write("logi_verzeichnis = \"Fr\"" + System.lineSeparator())
|
|
lPathJPL.append("dokuart = \"${Const.gDTS_DKUKO}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_STATUS}] = \"" + checkValueForJpl(ln1) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_PROZESS}] = \"" + checkValueForJpl(ln5) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ABTSENDER}] = \"" + checkValueForJpl(ln6) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_SENDER}] = \"" + checkValueForJpl(ln7) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_PROJKLAMMER}] = \"" + checkValueForJpl(ln8) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_RESPSALESMAN}] = \"" + checkValueForJpl(ln14) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKTITLE}] = \"" + checkValueForJpl(ln17) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_AUFTRNR}] = \"" + checkValueForJpl(doc.field[Const.gDDF_AUFTRNR]) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"" + checkValueForJpl(ln21) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KNR}] = \"" + checkValueForJpl(ln22) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KNAME}] = \"" + checkValueForJpl(ln23) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KDAKTNAME}] = \"" + checkValueForJpl(ln24) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_BUCHKREIS}] = \"" + checkValueForJpl(ln28) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_OPPNUMMER}] = \"" + checkValueForJpl(doc.field[Const.gDDF_OPPNUMMER]) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KOMMRICHTUNG}] = \"" + checkValueForJpl(ln32) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_JAHR}] = \"" + checkValueForJpl(ln33) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_MONAT}] = \"" + checkValueForJpl(ln34) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_VKPHASE}] = \"" + checkValueForJpl(ln35) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_HAUPTOPP}] = \"" + checkValueForJpl(ln36) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_SUBMISSION}] = \"" + checkValueForJpl(ln37) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDFF_ABTEILUNG}] = \"" + checkValueForJpl(ln39) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ERGEBNISDOK}] = \"" + checkValueForJpl(ln44) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KDAKTKAT}] = \"" + checkValueForJpl(ln45) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_SALESGROUP}] = \"" + checkValueForJpl(ln47) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ARCDOCID}] = \"" + checkValueForJpl(ln49) + "\"" + System.lineSeparator())
|
|
if(ln50 != null && !ln50.equals("")) {
|
|
Date date50 = new Date(ln50.getTime());
|
|
SimpleDateFormat sdf50 = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
|
|
String formatDateTime50 = sdf50.format(date50);
|
|
formatDateTime50 = formatDateTime50.replace(":", "\\:")
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ERDATE}] = \"" + formatDateTime50 + "\"" + System.lineSeparator())
|
|
}
|
|
if(ln52 != null && !ln52.equals("")) {
|
|
Date date52 = new Date(ln52.getTime());
|
|
SimpleDateFormat sdf52 = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
|
|
String formatDateTime52 = sdf52.format(date52);
|
|
formatDateTime52 = formatDateTime52.replace(":", "\\:")
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KONTAKTDATE}] = \"" + formatDateTime52 + "\"" + System.lineSeparator())
|
|
}
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOCINFONR}] = \"" + checkValueForJpl(ln80.toString()) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KONTAKTNUMMER}] = \"" + checkValueForJpl(ln15.toString()) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("text[4] = \"" + sqlResult.getAt(i).get("lDKUKODocID") + "\"" + System.lineSeparator())
|
|
|
|
for(int j=1; j <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); j++) {
|
|
if(ln60 != null && ln60.size() > 0) {
|
|
if( !doc.field[Const.gDDF_ABTEMPM][j].equals("") && doc.field[Const.gDDF_ABTEMPM][j] != null) {
|
|
lPathJPL.append("dok_dat_feld_${Const.gDDF_ERGDOCFUER}[${j}] = \"" + checkValueForJpl(ln60.get(j)) + "\"" + System.lineSeparator())
|
|
}
|
|
}
|
|
if(ln63 != null && ln63.size() > 0) {
|
|
if( !doc.field[Const.gDDF_ABTEMPM][j].equals("") && doc.field[Const.gDDF_ABTEMPM][j] != null ) {
|
|
lPathJPL.append("dok_dat_feld_${Const.gDDF_ABTEMPM}[${j}] = \"" + checkValueForJpl(ln63[j]) + "\"" + System.lineSeparator())
|
|
}
|
|
}
|
|
if(ln68 != null && ln68.size() > 0) {
|
|
if( !doc.field[Const.gDDF_BUCHKREIS68][j].equals("") && doc.field[Const.gDDF_BUCHKREIS68][j] != null ) {
|
|
lPathJPL.append("dok_dat_feld_${Const.gDDF_BUCHKREIS68}[${j}] = \"" + checkValueForJpl(ln68[j]) + "\"" + System.lineSeparator())
|
|
}
|
|
}
|
|
if(ln65 != null && ln65.size() > 0) {
|
|
if( !doc.field[Const.gDDF_EMPFAENGERM][j].equals("") && doc.field[Const.gDDF_EMPFAENGERM] != null ) {
|
|
lPathJPL.append("dok_dat_feld_${Const.gDDF_EMPFAENGERM}[${j}] = \"" + checkValueForJpl(ln65[j]) + "\"" + System.lineSeparator())
|
|
}
|
|
}
|
|
}
|
|
|
|
lPathD3L.write("idlist" + System.lineSeparator());
|
|
lPathD3L.append("${sqlResult.getAt(i).get("lDKUKODocID")}" + System.lineSeparator());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Organisation D3L Dateien für ECR
|
|
* @author
|
|
* @see LinkEntry
|
|
* @return keine Rückgabe; im Hintergrund werden D3L-Dateien erstellt
|
|
*/
|
|
public static void createD3lForECR( D3Interface d3, def docIdChild, def docIdFather ) {
|
|
d3.log.info("Start Functions createD3lForECR");
|
|
|
|
//Erstelle d3l Dateien zu einem Dokument, wenn weitere Aufträge eingegeben werden
|
|
|
|
// Wir kommen aus dem Link Entry
|
|
// Übergeben wird
|
|
// - pDocId = Die Dokument ID des auslösenden Kindes !Originaldokument! -> docIdchild
|
|
// - pDocIdFather = Hier ist der neue Vater enthalten, die Akte in die die D3L kopiert werden soll -> docIdFather
|
|
|
|
def lReturn
|
|
def lWeitAuftragsnrCount
|
|
List<String> lErgDoc60 = new ArrayList<>();
|
|
List<String> lWeitAuftragsnr = new ArrayList<>();
|
|
def lD3LStop
|
|
def lDateTime
|
|
|
|
Document docTemp = d3.archive.getDocument(docIdChild, "d3groovy");
|
|
|
|
def sqlStatement1 =
|
|
"SELECT dok_dat_feld_${Const.gDDF_BESCHREIBUNG} as In24, dok_dat_feld_${Const.gDDF_ERGEBNISDOK} as ln44 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE doku_id = '${docIdChild}' "
|
|
List<GroovyRowResult> sqlResult1 = d3.sql.executeAndGet(sqlStatement1);
|
|
def In24 = sqlResult1.getAt(0).get("In24")
|
|
def ln44 = sqlResult1.getAt(0).get("ln44")
|
|
|
|
// Projektnummer des Vaters ermitteln, für korrekten Durchlauf Aktenplan
|
|
def sqlStatement2 =
|
|
"SELECT dok_dat_feld_${Const.gDDF_AUFTRNR} as In19 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE doku_id = '${docIdFather}' "
|
|
List<GroovyRowResult> sqlResult2 = d3.sql.executeAndGet(sqlStatement2);
|
|
def In19 = sqlResult2.getAt(0).get("In19")
|
|
|
|
// DBMS ALIAS In24, In28, In80, In21, In18, In17, In43, In33, In23, In22, In34, In8, In5, In2, In1, In37, In15, In50
|
|
def sqlStatement3 =
|
|
"SELECT dok_dat_feld_${Const.gDDF_BESCHREIBUNG} as In24, " +
|
|
"dok_dat_feld_${Const.gDDF_BUCHKREIS} as In28, " +
|
|
"dok_dat_feld_${Const.gDDF_DOCINFONR} as In80, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKGROUP} as In21, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKGRP} as In18, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKTITLE} as In17, " +
|
|
"dok_dat_feld_${Const.gDDF_ECRSTATUS} as In43, " +
|
|
"dok_dat_feld_${Const.gDDF_JAHR} as In33, " +
|
|
"dok_dat_feld_${Const.gDDF_KNAME} as In23, " +
|
|
"dok_dat_feld_${Const.gDDF_KNR} as In22, " +
|
|
"dok_dat_feld_${Const.gDDF_MONAT} as In34, " +
|
|
"dok_dat_feld_${Const.gDDF_PROJKLAMMER} as In8, " +
|
|
"dok_dat_feld_${Const.gDDF_PROZESS} as In5, " +
|
|
"dok_dat_feld_${Const.gDDF_PSPELEMENT} as In2, " +
|
|
"dok_dat_feld_${Const.gDDF_STATUS} as In1, " +
|
|
"dok_dat_feld_${Const.gDDF_SUBMISSION} as In37, " +
|
|
"dok_dat_feld_${Const.gDDF_AKTIVITAETSID} as In15, " +
|
|
"dok_dat_feld_${Const.gDDF_ERDATE} as In50 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE doku_id = '${docIdChild}' "
|
|
|
|
List<GroovyRowResult> sqlResult3 = d3.sql.executeAndGet(sqlStatement3);
|
|
In24 = sqlResult3.getAt(0).get("In24")
|
|
def In28 = sqlResult3.getAt(0).get("In28")
|
|
def In80 = sqlResult3.getAt(0).get("In80")
|
|
def In21 = sqlResult3.getAt(0).get("In21")
|
|
def In18 = sqlResult3.getAt(0).get("In18")
|
|
def In17 = sqlResult3.getAt(0).get("In17")
|
|
def In43 = sqlResult3.getAt(0).get("In43")
|
|
def In33 = sqlResult3.getAt(0).get("In33")
|
|
def In23 = sqlResult3.getAt(0).get("In23")
|
|
def In22 = sqlResult3.getAt(0).get("In22")
|
|
def In34 = sqlResult3.getAt(0).get("In34")
|
|
def In8 = sqlResult3.getAt(0).get("In8")
|
|
def In5 = sqlResult3.getAt(0).get("In5")
|
|
def In2 = sqlResult3.getAt(0).get("In2")
|
|
def In1 = sqlResult3.getAt(0).get("In1")
|
|
def In37 = sqlResult3.getAt(0).get("In37")
|
|
def In15 = sqlResult3.getAt(0).get("In15")
|
|
def In50 = sqlResult3.getAt(0).get("In50")
|
|
|
|
|
|
// Eine eindeutige Erkennung eines bereits kopierten Kindes ist
|
|
// - Die Projektnummer (DDF 19 gDDF_AUFTRNR)
|
|
// - die Aktivitäts-ID (gDDF_AKTIVITAETSID DDF 15) und
|
|
// - Im Bemerkungsfeld 4 die Dokument ID des Kindes
|
|
def sqlStatement4 =
|
|
"SELECT pd.text as lBemerkung " +
|
|
"FROM phys_datei as pd, firmen_spezifisch as fs " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.kue_dokuart = '${Const.gDTS_DMECR}' " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_AKTIVITAETSID} = '${In15}' " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_AUFTRNR} = '${In19}' "
|
|
List<GroovyRowResult> sqlResult4 = d3.sql.executeAndGet(sqlStatement4)
|
|
|
|
if(sqlResult4 != null && sqlResult4.size() > 0) {
|
|
lD3LStop = 0
|
|
// Wenn im Bemerkungsfeld die Dokument ID des Original-Kind-Dokuments enthalten ist dann erfolgt keine Kopie
|
|
for( GroovyRowResult grr : sqlResult4 ) {
|
|
|
|
if( grr.get("lBemerkung") != null && !grr.get("lBemerkung").equals("") ) {
|
|
lReturn = grr.get("lBemerkung").indexOf(docIdChild);
|
|
|
|
if( lReturn > 0 ) {
|
|
d3.log.error( "Dieses Dokument ${docIdChild} wurde bereits verlinkt. Verlinkung wird nicht durchgeführt." )
|
|
lD3LStop = 1
|
|
} else {
|
|
// d3.log.error( "Nicht gefunden! Es darf gelinkt werden." )
|
|
// Alles OK, das cloning wird gestartet.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( lD3LStop != 1 ) {
|
|
if( In21.equals("") ) {
|
|
In21 = "ECR"
|
|
}
|
|
|
|
def sqlStatement5 =
|
|
"SELECT value_char as lErgDoc60 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${docIdChild}' " +
|
|
"AND field_no = '${Const.gDDF_ERGDOCFUER}' "
|
|
List<GroovyRowResult> sqlResult5 = d3.sql.executeAndGet(sqlStatement5)
|
|
for(GroovyRowResult grr : sqlResult5) {
|
|
lErgDoc60.add( grr.get("lErgDoc60") )
|
|
}
|
|
|
|
def sqlStatement6 =
|
|
"SELECT value_char as lWeitAuftragsnr66 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${docIdChild}' " +
|
|
"AND field_no = '${Const.gDDF_WEITAUFTRAGSNR}' "
|
|
List<GroovyRowResult> sqlResult6 = d3.sql.executeAndGet(sqlStatement6)
|
|
for(GroovyRowResult grr : sqlResult6) {
|
|
lWeitAuftragsnr.add( grr.get("lWeitAuftragsnr66") )
|
|
}
|
|
lWeitAuftragsnrCount = lWeitAuftragsnr.size()
|
|
|
|
// Tag zweistellig, Monat zweistellig, Jahr viertstellig, Minute zweistellig, Sekunde zweistellig Milisekunde dreistellig,
|
|
def date = new Date()
|
|
def sdf = new SimpleDateFormat("ddMMyyyy")
|
|
lDateTime = sdf.format(date)
|
|
|
|
File fileD3L = new File( "F:\\d3\\Hostimport\\LinkFiles\\CopyECR" + "_" + In19 + "_" + docIdChild + "_30_" + lDateTime + "_" + docTemp.field[Const.gDDF_AKTIVITAETSID] + ".d3l" )
|
|
File fileJPL = new File( "F:\\d3\\Hostimport\\LinkFiles\\CopyECR" + "_" + In19 + "_" + docIdChild + "_30_" + lDateTime + "_" + docTemp.field[Const.gDDF_AKTIVITAETSID] + ".jpl" )
|
|
|
|
fileD3L.write( "idlist" + System.lineSeparator())
|
|
fileD3L.append( "${docIdChild}" )
|
|
|
|
fileJPL.write( "logi_verzeichnis = 'Fr' " + System.lineSeparator())
|
|
fileJPL.append( "dokuart = '${Const.gDTS_DMECR}'" + System.lineSeparator())
|
|
if(In24 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_BESCHREIBUNG}] = \"" + In24 + "\"" + System.lineSeparator())
|
|
}
|
|
if(ln44 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_ERGEBNISDOK}] = \"" + ln44 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In28 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_BUCHKREIS}] = \"" + In28 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In80 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_DOCINFONR}] = \"" + In80 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In21 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"" + In21 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In18 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_DOKGRP}] = \"" + In18 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In17 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_DOKTITLE}] = \"" + In17 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In43 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_ECRSTATUS}] = \"" + In43 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In33 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_JAHR}] = \"" + In33 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In23 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_KNAME}] = \"" + In23 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In22 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_KNR}] = \"" + In22 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In34 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_MONAT}] = \"" + In34 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In8 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_PROJKLAMMER}] = \"" + In8 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In19 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_AUFTRNR}] = \"" + In19 + "\"" + System.lineSeparator() )
|
|
}
|
|
if(In5 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_PROZESS}] = \"" + In5 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In2 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_PSPELEMENT}] = \"" + In2 + "\"" +System.lineSeparator())
|
|
}
|
|
if(In1 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_STATUS}] = \"" + In1 + "\"" + System.lineSeparator())
|
|
}
|
|
if(In37 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_SUBMISSION}] = \"" + In37 + "\"" + System.lineSeparator())
|
|
}
|
|
if(docTemp.field[Const.gDDF_SUBJECT] != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_SUBJECT}] = \"" + docTemp.field[Const.gDDF_SUBJECT] + "\"" + System.lineSeparator())
|
|
}
|
|
if(In15 != null) {
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_AKTIVITAETSID}] = \"" + In15 + "\"" + System.lineSeparator())
|
|
}
|
|
|
|
// Der Hostimport erwartet ein bestimmtes Format, daher muss der Timestamp angepasst werden
|
|
Date date50 = new Date(In50.getTime());
|
|
SimpleDateFormat sdf50 = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
|
|
String formatDateTime50 = sdf50.format(date50);
|
|
formatDateTime50 = formatDateTime50.replace(":", "\\:")
|
|
|
|
fileJPL.append( "dok_dat_feld[${Const.gDDF_ERDATE}] = \"" + formatDateTime50 + "\"" + System.lineSeparator())
|
|
fileJPL.append( "text[4] = \"" + docIdChild + "\"" + System.lineSeparator())
|
|
|
|
for( int i = 1; i <= lErgDoc60.size(); i++ ) {
|
|
fileJPL.append( "dok_dat_feld_:gDDF_ERGDOCFUER[:lCount] = \"" + lErgDoc60[i] + "\"" + System.lineSeparator())
|
|
}
|
|
|
|
for( int i = 1; i <= lWeitAuftragsnrCount; i++ ) {
|
|
fileJPL.append( "dok_dat_feld_${Const.gDDF_WEITAUFTRAGSNR[i]} = \"" + lWeitAuftragsnr[i] + "\"" + System.lineSeparator())
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Organisation D3L Dateien für "Kundendokumente" und "Lieferantendokumente"
|
|
* @author Maschinenprojekt
|
|
* @see InsertExit, UpdateAttributExit, NewVersionExit
|
|
* @return keine Rückgabe; im Hintergrund wird eine D3L-Datei erstellt, gesperrt oder entsperrt
|
|
*/
|
|
public static void createD3lForSuppCusto( D3Interface d3, def lBlock, def lNumberToConnect, def lScenario, def lOriginDocId ) {
|
|
d3.log.info("Start Functions createD3lForSuppCusto");
|
|
|
|
def lChildOrigID
|
|
def lSQL
|
|
def lChildCount
|
|
def lChildBlockStatus
|
|
def lReturn
|
|
def lSQLRDID
|
|
|
|
Document doc = d3.archive.getDocument(lOriginDocId)
|
|
|
|
d3.log.info( "manage_d3l_Supp_Custo( ${lBlock}, ${lNumberToConnect}, ${lScenario}, ${lOriginDocId} )" )
|
|
// Neuer Eintrag weitere Lieferant_Nr bzw. weitere Kunden_Nr -> Erstellung der D3L
|
|
// Erneuter Eintrag weitere Lieferant_Nr bzw. weitere Kunden_Nr -> Freigabe der D3L
|
|
// Löschen eines Eintrags weitere Lieferant_Nr bzw. weitere Kunden_Nr -> Sperrung der D3L
|
|
|
|
if( lScenario.equals("CustomerNumber") ) {
|
|
lSQL = "AND fs.kue_dokuart = '${Const.gDTS_DKUMA}' AND fs.dok_dat_feld_${Const.gDDF_KNR} = '${lNumberToConnect}' "
|
|
} else if( lScenario.equals("SupplierNumber") ) {
|
|
lSQL = "AND fs.kue_dokuart = '${Const.gDTS_DLIMA}' AND fs.dok_dat_feld_${Const.gDDF_LNR} = '${lNumberToConnect}' "
|
|
}
|
|
|
|
def sqlStatement = "SELECT pd.doku_id as lChildOrigID, pd.frei_o_gesperrt as lChildBlockStatus " +
|
|
"FROM phys_datei as pd, firmen_spezifisch as fs " +
|
|
"WHERE fs.doku_id = pd.doku_id " + lSQL +
|
|
"AND pd.datei_erw = 'D3L' " +
|
|
"AND ( pd.text LIKE '%${lOriginDocId}%' OR pd.text LIKE '%${lOriginDocId}' OR pd.text LIKE '${lOriginDocId}%' ) "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
lChildCount = sqlResult.size()
|
|
if( lChildCount > 0 ) {
|
|
lChildOrigID = sqlResult.getAt(0).get("lChildOrigID")
|
|
lChildBlockStatus = sqlResult.getAt(0).get("lChildBlockStatus")
|
|
}
|
|
|
|
if( lBlock.equals("CREATE/UNBLOCK") ) {
|
|
// Neuer Eintrag weitere Lieferant_Nr bzw. weitere Kunden_Nr -> Erstellung der D3L
|
|
// Erneuter Eintrag weitere Lieferant_Nr bzw. weitere Kunden_Nr -> Freigabe der D3L
|
|
|
|
// Gibt es bereits eine D3L?
|
|
if( lChildCount == 1 ) {
|
|
|
|
// UNBLOCK
|
|
if( !lChildBlockStatus.equals("f") ) {
|
|
lReturn = d3.call.document_block(false, "d3groovy", lChildOrigID)
|
|
if (lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lChildOrigID} konnte nicht Entsperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
} else {
|
|
// d3.log.error( "Hier werden D3L erstellt für lNumberToConnect " + lNumberToConnect )
|
|
// CREATE
|
|
// Alle Daten des Original-Dokuments holen
|
|
// Holen aller Daten aus dem Child-Dokument
|
|
|
|
def In1, In4, In5, In6, In7, In17, In21, In32, In33, In34, In39, In48, In49, In50, In80
|
|
def ln63Count, ln65Count, ln62Count, ln66Count
|
|
List<String> In63 = new ArrayList<>();
|
|
List<String> In65 = new ArrayList<>();
|
|
// Kundendokumente
|
|
def In22, In23, In28
|
|
List<String> In62 = new ArrayList<>();
|
|
// Lieferantendokumente
|
|
def In10, In11
|
|
List<String> In66 = new ArrayList<>();
|
|
|
|
def sqlFurtherFields
|
|
def lNameToConnect
|
|
if( lScenario.equals("CustomerNumber") ) {
|
|
|
|
def sqlStatementFirst = "SELECT dok_dat_feld_${Const.gDDF_STATUS} as In1, " +
|
|
"dok_dat_feld_${Const.gDDF_PROZESS} as In5, " +
|
|
"dok_dat_feld_${Const.gDDF_ABTSENDER} as In6, " +
|
|
"dok_dat_feld_${Const.gDDF_SENDER} as In7, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKTITLE} as In17, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKGROUP} as In21, " +
|
|
"dok_dat_feld_${Const.gDDF_KOMMRICHTUNG} as In32, " +
|
|
"dok_dat_feld_${Const.gDDF_JAHR} as In33, " +
|
|
"dok_dat_feld_${Const.gDDF_MONAT} as In34, " +
|
|
"dok_dat_feld_${Const.gDFF_ABTEILUNG} as In39, " +
|
|
"dok_dat_feld_${Const.gDDF_SUBJECT} as In48, " +
|
|
"dok_dat_feld_${Const.gDDF_ARCDOCID} as In49, " +
|
|
"dok_dat_feld_${Const.gDDF_ERDATE} as In50, " +
|
|
"dok_dat_feld_${Const.gDDF_DOCINFONR} as In80, " +
|
|
"dok_dat_feld_${Const.gDDF_KNR} as In22, " +
|
|
"dok_dat_feld_${Const.gDDF_KNAME} as In23, " +
|
|
"dok_dat_feld_${Const.gDDF_BUCHKREIS} as In28 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE doku_id = '${lOriginDocId}' "
|
|
|
|
GroovyRowResult grrFirst = d3.sql.firstRow(sqlStatementFirst);
|
|
In1 = grrFirst.get("In1")
|
|
In5 = grrFirst.get("In5")
|
|
In6 = grrFirst.get("In6")
|
|
In7 = grrFirst.get("In7")
|
|
In17 = grrFirst.get("In17")
|
|
In21 = grrFirst.get("In21")
|
|
In32 = grrFirst.get("In32")
|
|
In33 = grrFirst.get("In33")
|
|
In34 = grrFirst.get("In34")
|
|
In39 = grrFirst.get("In39")
|
|
In48 = grrFirst.get("In48")
|
|
In49 = grrFirst.get("In49")
|
|
In50 = grrFirst.get("In50")
|
|
In80 = grrFirst.get("In80")
|
|
In22 = grrFirst.get("In22")
|
|
In23 = grrFirst.get("In23")
|
|
In28 = grrFirst.get("In28")
|
|
|
|
def sqlStatementSec = "SELECT dok_dat_feld_${Const.gDDF_KNAME} as lNameToConnect " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AKUND}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KNR} = '${lNumberToConnect}' "
|
|
|
|
GroovyRowResult grrSec = d3.sql.firstRow(sqlStatementSec);
|
|
lNameToConnect = grrSec.get("lNameToConnect")
|
|
|
|
} else if( lScenario.equals("SupplierNumber") ) {
|
|
|
|
def sqlStatementFirst = "SELECT dok_dat_feld_${Const.gDDF_STATUS} as In1, " +
|
|
"dok_dat_feld_${Const.gDDF_PROZESS} as In5, " +
|
|
"dok_dat_feld_${Const.gDDF_ABTSENDER} as In6, " +
|
|
"dok_dat_feld_${Const.gDDF_SENDER} as In7, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKTITLE} as In17, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKGROUP} as In21, " +
|
|
"dok_dat_feld_${Const.gDDF_KOMMRICHTUNG} as In32, " +
|
|
"dok_dat_feld_${Const.gDDF_JAHR} as In33, " +
|
|
"dok_dat_feld_${Const.gDDF_MONAT} as In34, " +
|
|
"dok_dat_feld_${Const.gDFF_ABTEILUNG} as In39, " +
|
|
"dok_dat_feld_${Const.gDDF_SUBJECT} as In48, " +
|
|
"dok_dat_feld_${Const.gDDF_ARCDOCID} as In49, " +
|
|
"dok_dat_feld_${Const.gDDF_ERDATE} as In50, " +
|
|
"dok_dat_feld_${Const.gDDF_DOCINFONR} as In80, " +
|
|
"dok_dat_feld_${Const.gDDF_LNR} as In10, " +
|
|
"dok_dat_feld_${Const.gDDF_LNAME} as In11 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE doku_id = '${lOriginDocId}' "
|
|
|
|
GroovyRowResult grrFirst = d3.sql.firstRow(sqlStatementFirst);
|
|
In1 = grrFirst.get("In1")
|
|
In5 = grrFirst.get("In5")
|
|
In6 = grrFirst.get("In6")
|
|
In7 = grrFirst.get("In7")
|
|
In17 = grrFirst.get("In17")
|
|
In21 = grrFirst.get("In21")
|
|
In32 = grrFirst.get("In32")
|
|
In33 = grrFirst.get("In33")
|
|
In34 = grrFirst.get("In34")
|
|
In39 = grrFirst.get("In39")
|
|
In48 = grrFirst.get("In48")
|
|
In49 = grrFirst.get("In49")
|
|
In50 = grrFirst.get("In50")
|
|
In80 = grrFirst.get("In80")
|
|
In10 = grrFirst.get("In10")
|
|
In11 = grrFirst.get("In11")
|
|
|
|
def sqlStatementSec = "SELECT dok_dat_feld_${Const.gDDF_LNAME} as lNameToConnect " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ALIEF}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_LNR} = '${lNumberToConnect}' "
|
|
|
|
GroovyRowResult grrSec = d3.sql.firstRow(sqlStatementSec);
|
|
lNameToConnect = grrSec.get("lNameToConnect")
|
|
}
|
|
|
|
def sqlStatement63 = "SELECT value_char as In63 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${lOriginDocId}' " +
|
|
"AND field_no = '${Const.gDDF_ABTEMPM}' "
|
|
List<GroovyRowResult> sqlResult63 = d3.sql.executeAndGet(sqlStatement63);
|
|
ln63Count = sqlResult63.size()
|
|
for(GroovyRowResult grr : sqlResult63) {
|
|
In63.add(grr.get("In63"))
|
|
}
|
|
|
|
def sqlStatement65 = "SELECT value_char as In65 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${lOriginDocId}' " +
|
|
"AND field_no = '${Const.gDDF_EMPFAENGERM}' "
|
|
List<GroovyRowResult> sqlResult65 = d3.sql.executeAndGet(sqlStatement65);
|
|
ln65Count = sqlResult65.size()
|
|
for(GroovyRowResult grr : sqlResult65) {
|
|
In65.add(grr.get("In65"))
|
|
}
|
|
|
|
if( lScenario.equals("CustomerNumber") ) {
|
|
def sqlStatement62 = "SELECT value_char as In62 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${lOriginDocId}' " +
|
|
"AND field_no = '${Const.gDDF_WEITKDNR}' "
|
|
List<GroovyRowResult> sqlResult62 = d3.sql.executeAndGet(sqlStatement62);
|
|
ln62Count = sqlResult62.size()
|
|
for(GroovyRowResult grr : sqlResult62) {
|
|
In62.add(grr.get("In62"))
|
|
}
|
|
} else if( lScenario.equals("SupplierNumber") ) {
|
|
def sqlStatement66 = "SELECT value_char as In66 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${lOriginDocId}' " +
|
|
"AND field_no = '${Const.gDDF_WEITLIEFNR}' "
|
|
List<GroovyRowResult> sqlResult66 = d3.sql.executeAndGet(sqlStatement66);
|
|
ln66Count = sqlResult66.size()
|
|
for(GroovyRowResult grr : sqlResult66) {
|
|
In66.add(grr.get("In66"))
|
|
}
|
|
}
|
|
|
|
def date = new Date()
|
|
def sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS")
|
|
def lKey = sdf.format(date).toString()
|
|
|
|
// 04.10.2019 imue -> Aufgrund von Fehlersituationen mit dem Dateinamen den Dokumenttitel bei der Bennenung entfernt
|
|
File lPathD3L = new File("F:\\d3\\Hostimport\\LinkFiles\\CopyCustSupp" + "_" + lOriginDocId + "_" + lKey + ".d3l")
|
|
File lPathJPL = new File("F:\\d3\\Hostimport\\LinkFiles\\CopyCustSupp" + "_" + lOriginDocId + "_" + lKey + ".jpl")
|
|
|
|
lPathJPL.append("logi_verzeichnis = \"Fr\"" + System.lineSeparator())
|
|
if( lScenario.equals("CustomerNumber") ) {
|
|
lPathJPL.append("dokuart = \"${Const.gDTS_DKUMA}\"" + System.lineSeparator())
|
|
} else if( lScenario.equals("SupplierNumber") ) {
|
|
lPathJPL.append("dokuart = \"${Const.gDTS_DLIMA}\"" + System.lineSeparator())
|
|
}
|
|
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_STATUS}] = \"" + checkValueForJpl(In1) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_PROZESS}] = \"" + checkValueForJpl(In5) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_ABTSENDER}] = \"" + checkValueForJpl(In6) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_SENDER}] = \"" + checkValueForJpl(In7) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_DOKTITLE}] = \"" + In17 + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"" + In21 + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_KOMMRICHTUNG}] = \"" + checkValueForJpl(In32) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_JAHR}] = \"" + checkValueForJpl(In33) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_MONAT}] = \"" + checkValueForJpl(In34) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDFF_ABTEILUNG}] = \"" + checkValueForJpl(In39) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_SUBJECT}] = \"" + checkValueForJpl(In48) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_ARCDOCID}] = \"" + checkValueForJpl(In49) + "\"" + System.lineSeparator())
|
|
|
|
// Der Hostimport erwartet ein bestimmtes Format, daher muss der Timestamp angepasst werden
|
|
Date date50 = new Date(In50.getTime());
|
|
SimpleDateFormat sdf50 = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
|
|
String formatDateTime50 = sdf50.format(date50);
|
|
formatDateTime50 = formatDateTime50.replace(":", "\\:")
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_ERDATE}] = \"" + formatDateTime50 + "\"" + System.lineSeparator())
|
|
|
|
if( lScenario.equals("CustomerNumber") ) {
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_KNR}] = \"" + lNumberToConnect + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_KNAME}] = \"" + lNameToConnect + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_BUCHKREIS}] = \"" + checkValueForJpl(In28) + "\"" + System.lineSeparator())
|
|
} else if( lScenario.equals("SupplierNumber") ) {
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_LNR}] = \"" + lNumberToConnect + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_LNAME}] = \"" + lNameToConnect + "\"" + System.lineSeparator())
|
|
}
|
|
|
|
lPathJPL.append( "text[4] = \"" + lOriginDocId + "\"" + System.lineSeparator())
|
|
|
|
for( String sIn62 : In62) {
|
|
int lCounter = 1
|
|
if( sIn62 != null ){
|
|
/* in Groovy nicht notwendig
|
|
lReturn = api_function( "string_mask_special_char", In62[:lCount] )
|
|
if( lReturn > 0 )
|
|
{
|
|
In62[:lCount] = api_converted_string
|
|
}
|
|
*/
|
|
lPathJPL.append( "dok_dat_feld_${Const.gDDF_WEITKDNR}[${lCounter}] = \"" + sIn62 + "\"" + System.lineSeparator())
|
|
lCounter = lCounter + 1;
|
|
}
|
|
}
|
|
|
|
for( String sIn63 : In63) {
|
|
int lCounter = 1
|
|
if( sIn63 != null ) {
|
|
/* in Groovy nicht notwendig?
|
|
lReturn = api_function( "string_mask_special_char", In63[:lCount] )
|
|
if( lReturn > 0 )
|
|
{
|
|
In63[:lCount] = api_converted_string
|
|
}
|
|
*/
|
|
lPathJPL.append( "dok_dat_feld_${Const.gDDF_ABTEMPM}[${lCounter}] = \"" + sIn63 + "\"" + System.lineSeparator())
|
|
lCounter = lCounter + 1;
|
|
}
|
|
}
|
|
|
|
for( String sIn66 : In66) {
|
|
int lCounter = 1
|
|
if( sIn66 != null ) {
|
|
/* in Groovy nicht notwendig?
|
|
lReturn = api_function( "string_mask_special_char", In66[:lCount] )
|
|
if( lReturn > 0 )
|
|
{
|
|
In66[:lCount] = api_converted_string
|
|
}
|
|
*/
|
|
lPathJPL.append( "dok_dat_feld_${Const.gDDF_WEITLIEFNR}[${lCounter}] = \"" + sIn66 + "\"" + System.lineSeparator())
|
|
lCounter = lCounter + 1;
|
|
}
|
|
}
|
|
|
|
for( String sIn65 : In65) {
|
|
int lCounter = 1
|
|
if( sIn65 != null) {
|
|
/* in Groovy nicht notwendig?
|
|
lReturn = api_function( "string_mask_special_char", In65[:lCount] )
|
|
if( lReturn > 0 )
|
|
{
|
|
In65[:lCount] = api_converted_string
|
|
}
|
|
*/
|
|
lPathJPL.append( "dok_dat_feld_${Const.gDDF_EMPFAENGERM}[${lCounter}] = \"" + sIn65 + "\"" + System.lineSeparator())
|
|
lCounter = lCounter + 1;
|
|
}
|
|
}
|
|
|
|
lPathD3L.append( "idlist" + System.lineSeparator())
|
|
lPathD3L.append( "${lOriginDocId}" )
|
|
|
|
}
|
|
|
|
} else if( lBlock.equals("BLOCK") && lChildCount >= 1 && lChildBlockStatus.equals("f") ) {
|
|
// Löschen eines Eintrags weitere Lieferant_Nr bzw. weitere Kunden_Nr -> Sperrung der D3L
|
|
// Gibt es bereits eine D3L? - doku_id abfragen
|
|
// BLOCK
|
|
lReturn = d3.call.document_block(true, "d3groovy", lChildOrigID)
|
|
if (lReturn != 0) {
|
|
d3.log.error("Das Dokument ${lChildOrigID} konnte nicht Gesperrt werden! Errorcode = ${lReturn}")
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Erstelle für alle Opportunity Nummern im 60er Feld eine D3L-Datei für den Hostimport
|
|
* @author Opportunity
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund wird eine D3L-Datei erstellt
|
|
*/
|
|
public static void createLinkFiles( D3Interface d3, def doku_id_ref, def lOppNR, def lProjNr, def lProzessart, def lDokIdFather, def lKdName, def lKdNummer, def lEntryPoint, def lKukoID ) {
|
|
d3.log.info("Start Functions createLinkFiles");
|
|
|
|
Document doc = d3.archive.getDocument(doku_id_ref, "d3groovy")
|
|
def doc_type_short = doc.getType().getId()
|
|
|
|
def date = new Date()
|
|
def sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS")
|
|
def lKey = sdf.format(date).toString()
|
|
|
|
// Prüfung der Dokumenteigenschaften auf Null-Values
|
|
def lDokGroup = checkIfNullValue(doc.field[Const.gDDF_DOKGROUP]);
|
|
def lDocTitle = checkIfNullValue(doc.field[Const.gDDF_DOKTITLE]);
|
|
def lERDate = doc.field[Const.gDDF_ERDATE];
|
|
def lUnit = checkIfNullValue(doc.field[Const.gDFF_ABTEILUNG]);
|
|
def lResDoc = checkIfNullValue(doc.field[Const.gDDF_ERGEBNISDOK]);
|
|
def lSuppName = checkIfNullValue(doc.field[Const.gDDF_LNAME]);
|
|
def lSuppNo = checkIfNullValue(doc.field[Const.gDDF_LNR]);
|
|
def lProcType = checkIfNullValue(doc.field[Const.gDDF_PROZESS]);
|
|
def lOrigOpNo = checkIfNullValue(doc.field[Const.gDDF_OPPNUMMER]);
|
|
def lOrigProjNo = checkIfNullValue(doc.field[Const.gDDF_AUFTRNR]);
|
|
def lActivityID = checkIfNullValue(doc.field[Const.gDDF_KONTAKTNUMMER]);
|
|
def lSubject = checkIfNullValue(doc.field[Const.gDDF_SUBJECT]);
|
|
lOppNR = checkIfNullValue(lOppNR);
|
|
lProjNr = checkIfNullValue(lProjNr);
|
|
|
|
def lCustName
|
|
def lCustNo
|
|
def lMainOpp
|
|
def lSubmission
|
|
def lANName
|
|
def lANNo
|
|
def lState
|
|
|
|
File lPathJPL = new File( "F:\\d3\\Hostimport\\LinkFiles\\" + doku_id_ref + "_" + lKey + "_" + lOppNR + "_" + lProjNr + "_" + doc_type_short + ".jpl" )
|
|
|
|
if( lOppNR != null && !lOppNR.equals("") ) {
|
|
def sqlStatement = "SELECT ISNULL(dok_dat_feld_${Const.gDDF_KNAME}, '') as lCustName, ISNULL(dok_dat_feld_${Const.gDDF_KNR}, '') as lCustNo, ISNULL(dok_dat_feld_${Const.gDDF_HAUPTOPP}, '') as lMainOpp, ISNULL(dok_dat_feld_${Const.gDDF_SUBMISSION}, '') as lSubmission, ISNULL(dok_dat_feld_${Const.gDDF_STATUS}, '') as lState " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AOPPU}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNR}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if( sqlResult != null && sqlResult.size() > 0 ) {
|
|
lCustName = sqlResult.getAt(0).get("lCustName")
|
|
lCustNo = sqlResult.getAt(0).get("lCustNo")
|
|
lMainOpp = sqlResult.getAt(0).get("lMainOpp")
|
|
lSubmission = sqlResult.getAt(0).get("lSubmission")
|
|
lState = sqlResult.getAt(0).get("lState")
|
|
}
|
|
|
|
} else if( lProjNr != null && !lProjNr.equals("") ) {
|
|
def sqlStatement = "SELECT ISNULL(dok_dat_feld_${Const.gDDF_KNAME}, '') as lCustName, ISNULL(dok_dat_feld_${Const.gDDF_KNR}, '') as lCustNo, ISNULL(dok_dat_feld_${Const.gDDF_SUBMISSION}, '') as lSubmission, ISNULL(dok_dat_feld_${Const.gDDF_STATUS}, '') as lState " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE ( kue_dokuart = '${Const.gDTS_AMPRA}' " +
|
|
"OR kue_dokuart = '${Const.gDTS_APREN}' ) " +
|
|
"AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lProjNr}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if( sqlResult != null && sqlResult.size() > 0 ) {
|
|
lCustName = sqlResult.getAt(0).get("lCustName")
|
|
lCustNo = sqlResult.getAt(0).get("lCustNo")
|
|
lSubmission = sqlResult.getAt(0).get("lSubmission")
|
|
lState = sqlResult.getAt(0).get("lState")
|
|
}
|
|
}
|
|
|
|
if( doc_type_short.equals(Const.gDTS_DKUKO) ) {
|
|
if( lProcType.equals("0201") && lOppNR == null && lOppNR.equals("") ) {
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_OPPNUMMER} as lOppNR " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AOPPU}' " +
|
|
"AND doku_id = '${lDokIdFather}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if( sqlResult != null && sqlResult.size() > 0 ) {
|
|
lOppNR = sqlResult.getAt(0).get("lOppNR")
|
|
}
|
|
} else if( lProcType.equals("0202") && lProjNr == null && lProjNr.equals("") ) {
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_AUFTRNR} as lProjNr " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE ( kue_dokuart = '${Const.gDTS_AMPRA}' " +
|
|
"OR kue_dokuart = '${Const.gDTS_APREN}' ) " +
|
|
"AND doku_id = '${lDokIdFather}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if( sqlResult != null && sqlResult.size() > 0 ) {
|
|
lProjNr = sqlResult.getAt(0).get("lProjNr")
|
|
}
|
|
} else if ( lProcType.equals("0200") ) {
|
|
lCustName = lKdName
|
|
lCustNo = lKdNummer
|
|
}
|
|
}
|
|
|
|
try {
|
|
|
|
// Anpassung 05.03.2018/dkle: Nur Erkennungsattribute befüllen, den Rest per Aktenplan ergänzen lassen
|
|
// Allgemein Attribute
|
|
lPathJPL.append("logi_verzeichnis = \"Fr\"" + System.lineSeparator())
|
|
lPathJPL.append("dokuart = \"${doc_type_short}\"" + System.lineSeparator())
|
|
lPathJPL.append("text[3] = \"${doku_id_ref}\"" + System.lineSeparator())
|
|
|
|
lPathJPL.append("dok_dat_feld[${Const.gDFF_ABTEILUNG}] = \"${checkValueForJpl(lUnit)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKTITLE}] = \"${checkValueForJpl(lDocTitle)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ERDATE}] = \"${lERDate}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ERGEBNISDOK}] = \"${checkValueForJpl(lResDoc)}\"" +System.lineSeparator())
|
|
|
|
if ( doc_type_short.equals(Const.gDTS_DKOMM) ) {
|
|
// Erkennungsattribute
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_PROZESS}] = \"${checkValueForJpl(lProcType)}\"" + System.lineSeparator()) // Prozessart
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KNR}] = \"${checkValueForJpl(lCustNo)}\"" + System.lineSeparator()) // Kunden_Nr
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_AUFTRNR}] = \"${checkValueForJpl(lProjNr)}\"" + System.lineSeparator()) // Projekt_Nr
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_OPPNUMMER}] = \"${checkValueForJpl(lOppNR)}\"" + System.lineSeparator()) // Opportunity_Nr
|
|
|
|
// weitere Attribute
|
|
lPathJPL.append("dok_dat_feld_${Const.gDDF_OPPNRM}[1] = \"${checkValueForJpl(lOrigOpNo)}\"" + System.lineSeparator())
|
|
|
|
} else if ( doc_type_short.equals(Const.gDTS_DLIKO ) ) {
|
|
// Erkennungsattribute
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_LNAME}] = \"${checkValueForJpl(lSuppName)}\"" + System.lineSeparator()) // Lieferant_Name
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_AUFTRNR}] = \"${checkValueForJpl(lProjNr)}\"" + System.lineSeparator()) // Projekt_Nr
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_OPPNUMMER}] = \"${checkValueForJpl(lOppNR)}\"" + System.lineSeparator()) // Opportunity_Nr
|
|
|
|
//Pflichtfelder
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_LNR}] = \"${checkValueForJpl(lSuppNo)}\"" + System.lineSeparator())
|
|
//Ergänzungsfelder
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"${checkValueForJpl(lDokGroup)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld_${Const.gDDF_OPPNRM}[1] = \"${checkValueForJpl(lOrigOpNo)}\"" + System.lineSeparator())
|
|
//call api_function("file_add_line", lPathJPL, "dok_dat_feld[:gDDF_PROZESSGROUP] = :+lProcGroup", "APPEND")
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_PROZESS}] = \"${checkValueForJpl(lProcType)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KNAME}] = \"${checkValueForJpl(lCustName)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KNR}] = \"${checkValueForJpl(lCustNo)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_HAUPTOPP}] = \"${checkValueForJpl(lMainOpp)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_SUBMISSION}] = \"${checkValueForJpl(lSubmission)}\"" + System.lineSeparator())
|
|
|
|
} else if ( doc_type_short.equals(Const.gDTS_DMAUF) || doc_type_short.equals(Const.gDTS_DMDOK) || doc_type_short.equals(Const.gDTS_DMSPE) ) {
|
|
// Erkennungsattribute
|
|
// Akte (oder Betreff/Subject) wird anhand der Dokumentgruppe automatisch ermittelt, daher muss sie gefüllt sein
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_AUFTRNR}] = \"${checkValueForJpl(lProjNr)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"${checkValueForJpl(lDokGroup)}\"" + System.lineSeparator())
|
|
|
|
} else if ( doc_type_short.equals(Const.gDTS_DOPPD) ) {
|
|
// Erkennungsattribute
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_OPPNUMMER}] = \"${checkValueForJpl(lOppNR)}\"" + System.lineSeparator()) // Opportunity_Nr
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ANNAME}] = 'angebotsübergreifend/vor Angebot'" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_OPPANNr}] = '99999'" + System.lineSeparator()) // Angebot_Nr
|
|
|
|
// Zusatzattribute
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"${checkValueForJpl(lDokGroup)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld_${Const.gDDF_OPPNRM}[1] = \"${checkValueForJpl(lOrigOpNo)}\"" + System.lineSeparator())
|
|
|
|
} else if ( doc_type_short.equals(Const.gDTS_DPRST) ) {
|
|
// Erkennungsattribute
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_OPPNUMMER}] = \"${checkValueForJpl(lOppNR)}\"" + System.lineSeparator()) // Opportunity_Nr
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_AUFTRNR}] = \"${checkValueForJpl(lProjNr)}\"" + System.lineSeparator()) // Projekt_Nr
|
|
// Wird anhand der Dokumentgruppe automatisch ermittelt:
|
|
// lPathJPL.append("dok_dat_feld[${Const.gDDF_SUBJECT}] = """)
|
|
|
|
// Zusatzattribute
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"${checkValueForJpl(lDokGroup)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_HAUPTOPP}] = \"${checkValueForJpl(lMainOpp)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_OPPNUMMER}] = \"${checkValueForJpl(lOppNR)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld_${Const.gDDF_OPPNRM}[1] = \"${checkValueForJpl(lOrigOpNo)}\"" + System.lineSeparator())
|
|
|
|
} else if ( doc_type_short.equals(Const.gDTS_DVERD) ) {
|
|
// Erkennungsattribute
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_OPPNUMMER}] = \"${checkValueForJpl(lOppNR)}\"" + System.lineSeparator()) // Opportunity_Nr
|
|
// Zusatzattribute
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"${checkValueForJpl(lDokGroup)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld_${Const.gDDF_OPPNRM}[1] = \"${checkValueForJpl(lOrigOpNo)}\"" + System.lineSeparator())
|
|
|
|
} else if ( doc_type_short.equals(Const.gDTS_DKUKO) ) {
|
|
//Erkennungsattribute
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_OPPNUMMER}] = \"${checkValueForJpl(lOppNR)}\"" + System.lineSeparator()) // Opportunity_Nr
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_AUFTRNR}] = \"${checkValueForJpl(lProjNr)}\"" + System.lineSeparator()) // Projekt_Nr
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KNR}] = \"${checkValueForJpl(lKdNummer)}\"" + System.lineSeparator())
|
|
if(lEntryPoint.equals("newVersion")) {
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KONTAKTNUMMER}] = \"${checkValueForJpl(lKukoID)}\"" + System.lineSeparator());
|
|
} else {
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KONTAKTNUMMER}] = \"${checkValueForJpl(lActivityID)}\"" + System.lineSeparator());
|
|
}
|
|
//Ergänzungsfelder
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"${checkValueForJpl(lDokGroup)}\"" + System.lineSeparator())
|
|
}
|
|
|
|
if( lSubject != null && !lSubject.equals("") ) {
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_SUBJECT}] = \"${checkValueForJpl(lSubject)}\"" + System.lineSeparator());
|
|
}
|
|
|
|
File lPathD3L = new File( "F:\\d3\\Hostimport\\LinkFiles\\" + doku_id_ref + "_" + lKey + "_" + lOppNR + "_" + lProjNr + "_" + doc_type_short + ".d3l" )
|
|
lPathD3L.append("idlist" + System.lineSeparator())
|
|
lPathD3L.append(doku_id_ref)
|
|
|
|
} catch(Exception e) {
|
|
d3.log.error("Die D3L Datei für Opportunity Nummer ${lOppNR} oder Maschinenprojektnummer ${lProjNr} mit Bezug auf Dokument ${doku_id_ref} konnte nicht erstellt werden! Errorcode = " + e )
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Erstelle für alle Service Nummern im 60er Feld (BelegNr, SR-ID) eine D3L-Datei für den Hostimport
|
|
* @author Service
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund wird eine D3L-Datei erstellt
|
|
*/
|
|
public static void createLinkFilesService( D3Interface d3, Document doc, def lBelegNr, def lSrId ) {
|
|
d3.log.info("Start Functions createLinkFilesService");
|
|
|
|
if(doc.getFileExtension() != null && !doc.getFileExtension().equals("d3l") && !doc.getFileExtension().equals("D3L")) {
|
|
|
|
d3.log.info("Funktion createLinkFilesService wurde gestartet!")
|
|
|
|
def doc_type_short = doc.getType().getId()
|
|
|
|
def date = new Date()
|
|
def sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS")
|
|
def lKey = sdf.format(date).toString()
|
|
|
|
// Prüfung der Dokumenteigenschaften auf Null-Values
|
|
def lDokGroup = checkIfNullValue(doc.field[Const.gDDF_DOKGROUP]);
|
|
def lDocTitle = checkIfNullValue(doc.field[Const.gDDF_DOKTITLE]);
|
|
def lERDate = doc.field[Const.gDDF_ERDATE];
|
|
def lProcType = checkIfNullValue(doc.field[Const.gDDF_PROZESS]);
|
|
lBelegNr = checkIfNullValue(lBelegNr);
|
|
lSrId = checkIfNullValue(lSrId);
|
|
|
|
def lCustName
|
|
def lCustNo
|
|
|
|
File lPathJPL = new File( "F:\\d3\\Hostimport\\LinkFiles\\" + doc.id() + "_" + lKey + "_" + lBelegNr + "_" + lSrId + "_" + doc_type_short + ".jpl" )
|
|
|
|
if( lBelegNr != null && !lBelegNr.equals("") ) {
|
|
def sqlStatement = "SELECT ISNULL(dok_dat_feld_${Const.gDDF_KNAME}, '') as lCustName, ISNULL(dok_dat_feld_${Const.gDDF_KNR}, '') as lCustNo " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ASEBE}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${lBelegNr}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if( sqlResult != null && sqlResult.size() > 0 ) {
|
|
lCustName = sqlResult.getAt(0).get("lCustName")
|
|
lCustNo = sqlResult.getAt(0).get("lCustNo")
|
|
}
|
|
|
|
} else if( lSrId != null && !lSrId.equals("") ) {
|
|
def sqlStatement = "SELECT ISNULL(dok_dat_feld_${Const.gDDF_KNAME}, '') as lCustName, ISNULL(dok_dat_feld_${Const.gDDF_KNR}, '') as lCustNo " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ASERE}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_SRID} = '${lSrId}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if( sqlResult != null && sqlResult.size() > 0 ) {
|
|
lCustName = sqlResult.getAt(0).get("lCustName")
|
|
lCustNo = sqlResult.getAt(0).get("lCustNo")
|
|
}
|
|
}
|
|
|
|
try {
|
|
|
|
// Allgemein Attribute
|
|
lPathJPL.append("logi_verzeichnis = \"Fr\"" + System.lineSeparator())
|
|
lPathJPL.append("dokuart = \"${doc_type_short}\"" + System.lineSeparator())
|
|
lPathJPL.append("text[3] = \"${doc.id()}\"" + System.lineSeparator())
|
|
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"${checkValueForJpl(lDokGroup)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKTITLE}] = \"${checkValueForJpl(lDocTitle)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ERDATE}] = \"${lERDate}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_PROZESS}] = \"${checkValueForJpl(lProcType)}\"" + System.lineSeparator())
|
|
|
|
if ( doc_type_short.equals(Const.gDTS_DSEBE) ) {
|
|
// Pflichtfelder
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_BELEGNUMMER}] = \"${checkValueForJpl(lBelegNr)}\"" + System.lineSeparator())
|
|
|
|
// weitere Attribute
|
|
|
|
} else if ( doc_type_short.equals(Const.gDTS_DSERE ) ) {
|
|
// Pflichtfelder
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_SRID}] = \"${checkValueForJpl(lSrId)}\"" + System.lineSeparator())
|
|
|
|
// weitere Attribute
|
|
}
|
|
|
|
File lPathD3L = new File( "F:\\d3\\Hostimport\\LinkFiles\\" + doc.id() + "_" + lKey + "_" + lBelegNr + "_" + lSrId + "_" + doc_type_short + ".d3l" )
|
|
lPathD3L.append("idlist" + System.lineSeparator())
|
|
lPathD3L.append(doc.id())
|
|
|
|
} catch(Exception e) {
|
|
d3.log.error("Die D3L Datei für ServiceBeleg Nummer ${lBelegNr} oder ServiceRequest ${lSrId} mit Bezug auf Dokument ${doc.id()} konnte nicht erstellt werden! Errorcode = " + e )
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Erstelle für alle Equipment Nummern im 60er Feld eine D3L-Datei für den Hostimport
|
|
* TODO - weitere Eigenschaften ergänzen
|
|
* @author Equipment
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund wird eine D3L-Datei erstellt
|
|
*/
|
|
public static void createLinkFilesEquipment( D3Interface d3, Document doc, String equipmentNo ) {
|
|
d3.log.info("Start Functions createLinkFilesEquipment");
|
|
|
|
if(doc.getFileExtension() != null && !doc.getFileExtension().equals("d3l") && !doc.getFileExtension().equals("D3L")) {
|
|
|
|
def doc_type_short = doc.getType().getId()
|
|
|
|
def date = new Date()
|
|
def sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS")
|
|
def lKey = sdf.format(date).toString()
|
|
|
|
// Prüfung der Dokumenteigenschaften auf Null-Values
|
|
equipmentNo = checkIfNullValue(equipmentNo);
|
|
|
|
File lPathJPL = new File( "F:\\d3\\Hostimport\\LinkFiles\\" + doc.id() + "_" + lKey + "_" + equipmentNo + "_" + doc_type_short + ".jpl" )
|
|
|
|
try {
|
|
|
|
// Allgemein Attribute
|
|
lPathJPL.append("logi_verzeichnis = \"Fr\"" + System.lineSeparator())
|
|
lPathJPL.append("dokuart = \"${doc_type_short}\"" + System.lineSeparator())
|
|
lPathJPL.append("text[3] = \"${doc.id()}\"" + System.lineSeparator())
|
|
|
|
// Pflichtfelder
|
|
String lDokGroup = checkIfNullValue(doc.field[Const.gDDF_DOKGROUP]);
|
|
String lDocTitle = checkIfNullValue(doc.field[Const.gDDF_DOKTITLE]);
|
|
String lProcType = checkIfNullValue(doc.field[Const.gDDF_PROZESS]);
|
|
String lFile = checkIfNullValue(doc.field[Const.gDDF_AKTE]);
|
|
|
|
def lERDate = doc.field[Const.gDDF_ERDATE];
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_EQUIPMENT}] = \"${equipmentNo}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"${lDokGroup}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKTITLE}] = \"${lDocTitle}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ERDATE}] = \"${lERDate}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_AKTE}] = \"${lFile}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_PROZESS}] = \"${checkValueForJpl(lProcType)}\"" + System.lineSeparator())
|
|
|
|
// weitere Attribute
|
|
// lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"${checkValueForJpl(lDokGroup)}\"" + System.lineSeparator())
|
|
|
|
File lPathD3L = new File( "F:\\d3\\Hostimport\\LinkFiles\\" + doc.id() + "_" + lKey + "_" + equipmentNo + "_" + doc_type_short + ".d3l" )
|
|
lPathD3L.append("idlist" + System.lineSeparator())
|
|
lPathD3L.append(doc.id())
|
|
|
|
} catch(Exception e) {
|
|
d3.log.error("Die D3L Datei für Equipment ${equipmentNo} mit Bezug auf Dokument ${doc.id()} konnte nicht erstellt werden! Errorcode = " + e )
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Erstellung D3l-Dateien für Original ECR-Dokumente
|
|
* @author
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund wird eine D3L-Datei erstellt
|
|
*/
|
|
public static void createLinkFilesOrder(D3Interface d3, Document doc, def docTypeShort) {
|
|
d3.log.info("Start Functions createLinkFilesOrder");
|
|
|
|
// aus der neuen Akte die Projektnummer holen
|
|
def In19 = doc.field[Const.gDDF_AUFTRNR]
|
|
|
|
def lD3LStop
|
|
List<String> lOriginalECRDocID = new ArrayList<>()
|
|
def lOriginalCount
|
|
def lActivity = doc.field[Const.gDDF_AKTIVITAETSID]
|
|
|
|
// Suche alle Unterakten ECR mit der gleichen Aktivitäts-ID DDF15, die im Bemerkungsfeld 4 "Original" stehen haben
|
|
// Es darf nur eine Akte sein!
|
|
// Projektnummer muss von der neuen Unterakte übernommen werden gDDF_AUFTRNR DDF 19
|
|
// gDDF_AUFTRNR
|
|
// Suche alle Dokumente in der Original Unterakte ECR
|
|
// erstelle D3L Dateien und importiere diese in die neue Unterakte ECR (geht per Projektnummer)
|
|
// Die Kenndaten sollen aus der neuen Unterakte ECR kommen
|
|
// Falls ein Dokument bereits hineinverlinkt wurde soll es nicht erneut dort hineinkommen.
|
|
|
|
// Ermittlung der Originalakte
|
|
def sqlStatement1 = "SELECT f.doku_id as lOriginalECRDocID " +
|
|
"FROM firmen_spezifisch as f, phys_datei as p " +
|
|
"WHERE f.kue_dokuart = '${Const.gDTS_AMECR}' " +
|
|
"AND ( p.text LIKE '%Original%' OR p.text LIKE '%Original' OR p.text LIKE 'Original%' ) " +
|
|
"AND f.doku_id = p.doku_id " +
|
|
"AND f.dok_dat_feld_${Const.gDDF_AKTIVITAETSID} = '${lActivity}' ";
|
|
List<GroovyRowResult> sqlResult1 = d3.sql.executeAndGet(sqlStatement1);
|
|
if(sqlResult1 != null && sqlResult1.size() > 0) {
|
|
lOriginalCount = sqlResult1.size()
|
|
for(GroovyRowResult grr : sqlResult1) {
|
|
lOriginalECRDocID.add(grr.get("lOriginalECRDocID"))
|
|
}
|
|
}
|
|
|
|
// Falls keine oder mehrere Akten mit der Aktivitäts-ID und dem Vermerk Original existieren -> Abbruch
|
|
if( lOriginalCount != 1 ) {
|
|
d3.log.error( "Für Aktivitäts-ID " + doc.field[Const.gDDF_AKTIVITAETSID] + " Keine Originalakte gefunden" )
|
|
} else {
|
|
// ansonsten Kopie der Originaldokumente per D3L in die neue Unterakte ECR
|
|
def lReturn
|
|
def lErgDocCount
|
|
def lWeitAuftragsnrCount
|
|
List<String> lErgDoc60 = new ArrayList<>()
|
|
List<String> lWeitAuftragsnr66 = new ArrayList<>()
|
|
List<String> lBemerkung = new ArrayList<>()
|
|
def lBemCounter
|
|
List<String> lChildOrigID = new ArrayList<>()
|
|
def lChildCount
|
|
def In4
|
|
|
|
// Alle Kinder der mit Original Markierten Akte holen (Eindeutigkeit über Aktivitätsid)
|
|
def sqlStatement2 = "SELECT pd.doku_id as lChildOrigID " +
|
|
"FROM phys_datei as pd, firmen_spezifisch as fs " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.kue_dokuart = '${Const.gDTS_DMECR}' " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_AKTIVITAETSID} = '${lActivity}' " +
|
|
"AND pd.datei_erw <> 'D3L' ";
|
|
List<GroovyRowResult> sqlResult2 = d3.sql.executeAndGet(sqlStatement2);
|
|
if(sqlResult2 != null && sqlResult2.size() > 0) {
|
|
lChildCount = sqlResult2.size()
|
|
for(GroovyRowResult grr : sqlResult2) {
|
|
lChildOrigID.add(grr.get("lChildOrigID"))
|
|
}
|
|
}
|
|
|
|
// Durchlauf für jedes Child-Dokument mit dem Ziel genau eine D3L Datei in der neuen Akte (pDocId) zu haben
|
|
for(int i=0; i<lChildCount; i++) {
|
|
lD3LStop = 0
|
|
// gDDF_BESCHREIBUNG 24, gDDF_BUCHKREIS 28, gDDF_DOCINFONR 80, gDDF_DOKGROUP 21, gDDF_DOKGRP 18
|
|
// gDDF_DOKTITLE 17, gDDF_ECRSTATUS 43, gDDF_JAHR 33, gDDF_KNAME 23, gDDF_KNR 22, gDDF_MONAT 34
|
|
// gDDF_PROJKLAMMER 8, gDDF_AUFTRNR 19, gDDF_PROZESSART 5, gDDF_PROZESSGROUP 4, gDDF_PSPELEMENT 2
|
|
// gDDF_STATUS 1, gDDF_SUBMISSION 37, gDDF_AKTIVITAETSID 15
|
|
// gDDF_ERGDOCFUER 60, gDDF_WEITAUFTRAGSNR 66
|
|
|
|
// Holen aller Daten aus dem Child-Dokument
|
|
def sqlStatement3 = "SELECT dok_dat_feld_${Const.gDDF_BESCHREIBUNG} as In24, " +
|
|
"dok_dat_feld_${Const.gDDF_BUCHKREIS} as In28, " +
|
|
"dok_dat_feld_${Const.gDDF_DOCINFONR} as In80, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKGROUP} as In21, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKGRP} as In18, " +
|
|
"dok_dat_feld_${Const.gDDF_DOKTITLE} as In17, " +
|
|
"dok_dat_feld_${Const.gDDF_ECRSTATUS} as In43, " +
|
|
"dok_dat_feld_${Const.gDDF_JAHR} as In33, " +
|
|
"dok_dat_feld_${Const.gDDF_KNAME} as In23, " +
|
|
"dok_dat_feld_${Const.gDDF_KNR} as In22, " +
|
|
"dok_dat_feld_${Const.gDDF_MONAT} as In34, " +
|
|
"dok_dat_feld_${Const.gDDF_PROJKLAMMER} as In8, " +
|
|
"dok_dat_feld_${Const.gDDF_PROZESS} as In5, " +
|
|
"dok_dat_feld_${Const.gDDF_PSPELEMENT} as In2, " +
|
|
"dok_dat_feld_${Const.gDDF_STATUS} as In1, " +
|
|
"dok_dat_feld_${Const.gDDF_SUBMISSION} as In37, " +
|
|
"dok_dat_feld_${Const.gDDF_AKTIVITAETSID} as In15, " +
|
|
"dok_dat_feld_${Const.gDDF_ERDATE} as In50, " +
|
|
"dok_dat_feld_${Const.gDDF_ERGEBNISDOK} as In44 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE doku_id = '${lChildOrigID.get(i)}' ";
|
|
List<GroovyRowResult> sqlResult3 = d3.sql.executeAndGet(sqlStatement3);
|
|
if(sqlResult3 != null && sqlResult3.size() > 0) {
|
|
|
|
def In24 = sqlResult3.getAt(0).get("In24")
|
|
def In28 = sqlResult3.getAt(0).get("In28")
|
|
def In80 = sqlResult3.getAt(0).get("In80")
|
|
def In21 = sqlResult3.getAt(0).get("In21")
|
|
def In18 = sqlResult3.getAt(0).get("In18")
|
|
def In17 = sqlResult3.getAt(0).get("In17")
|
|
def In43 = sqlResult3.getAt(0).get("In43")
|
|
def In33 = sqlResult3.getAt(0).get("In33")
|
|
def In23 = sqlResult3.getAt(0).get("In23")
|
|
def In22 = sqlResult3.getAt(0).get("In22")
|
|
def In34 = sqlResult3.getAt(0).get("In34")
|
|
def In8 = sqlResult3.getAt(0).get("In8")
|
|
def In5 = sqlResult3.getAt(0).get("In5")
|
|
def In2 = sqlResult3.getAt(0).get("In2")
|
|
def In1 = sqlResult3.getAt(0).get("In1")
|
|
def In37 = sqlResult3.getAt(0).get("In37")
|
|
def In15 = sqlResult3.getAt(0).get("In15")
|
|
def In50 = sqlResult3.getAt(0).get("In50")
|
|
def In44 = sqlResult3.getAt(0).get("In44")
|
|
|
|
// Eine eindeutige Erkennung eines bereits kopierten Kindes ist
|
|
// - Die Projektnummer (DDF 19 gDDF_AUFTRNR)
|
|
// - die Aktivitäts-ID (gDDF_AKTIVITAETSID DDF 15) und
|
|
// - Im Bemerkungsfeld 4 die Dokument ID des Kindes
|
|
|
|
def sqlStatement4 = "SELECT pd.text as lBemerkung " +
|
|
"FROM phys_datei as pd, firmen_spezifisch as fs " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.kue_dokuart = '${Const.gDTS_DMECR}' " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_AKTIVITAETSID} = '${In15}' " +
|
|
"AND fs.dok_dat_feld_${Const.gDDF_AUFTRNR} = '${In19}' ";
|
|
List<GroovyRowResult> sqlResult4 = d3.sql.executeAndGet(sqlStatement4);
|
|
if(sqlResult4 != null && sqlResult4.size() > 0) {
|
|
for(GroovyRowResult grr : sqlResult4) {
|
|
lBemerkung.add(grr.get("lBemerkung").toString().trim());
|
|
}
|
|
}
|
|
|
|
// Wenn im Bemerkungsfeld die Dokument ID des Original-Kind-Dokuments enthalten ist dann erfolgt keine Kopie
|
|
if(lBemerkung.contains(lChildOrigID.get(i))) {
|
|
d3.log.error( "Dieses Dokument ${lChildOrigID.get(i)} wurde bereits verlinkt. Verlinkung wird nicht durchgeführt." );
|
|
lD3LStop = 1;
|
|
} else {
|
|
// d3.log.error( "Nicht gefunden! Es darf gelinkt werden." )
|
|
// Alles OK, das cloning wird gestartet.
|
|
}
|
|
|
|
d3.log.info( "Bemerkungen sind durchgelaufen. Ergebnis: ${lD3LStop}" )
|
|
d3.log.info( "Bei 0 wird gecloned, bei 1 nicht" )
|
|
|
|
if( lD3LStop != 1 ) {
|
|
if( In21 == null ) {
|
|
In21 = "ECR"
|
|
}
|
|
|
|
def sqlStatement5 = "SELECT value_char as lErgDoc60 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${lChildOrigID.get(i)}' " +
|
|
"AND field_no = '${Const.gDDF_ERGDOCFUER}' ";
|
|
List<GroovyRowResult> sqlResult5 = d3.sql.executeAndGet(sqlStatement5);
|
|
if(sqlResult5 != null && sqlResult5.size() > 0) {
|
|
lErgDocCount = sqlResult5.size()
|
|
for(GroovyRowResult grr : sqlResult5) {
|
|
lErgDoc60.add(grr.get("lErgDoc60"))
|
|
}
|
|
}
|
|
|
|
def sqlStatement6 = "SELECT value_char as lWeitAuftragsnr66 " +
|
|
"FROM firm_spez_mult_val " +
|
|
"WHERE doku_id = '${lChildOrigID.get(i)}' " +
|
|
"AND field_no = '${Const.gDDF_WEITAUFTRAGSNR}' ";
|
|
List<GroovyRowResult> sqlResult6 = d3.sql.executeAndGet(sqlStatement6);
|
|
if(sqlResult6 != null && sqlResult6.size() > 0) {
|
|
lWeitAuftragsnrCount = sqlResult6.size()
|
|
for(GroovyRowResult grr : sqlResult6) {
|
|
lWeitAuftragsnr66.add(grr.get("lWeitAuftragsnr66"))
|
|
}
|
|
}
|
|
|
|
Date dateLog = new Date();
|
|
SimpleDateFormat sdfLog = new SimpleDateFormat("yyyyMMddHHmmss");
|
|
String dateString = sdfLog.format(dateLog);
|
|
|
|
File lPathD3L = new File("F:\\d3\\Hostimport\\LinkFiles\\CopyECR" + "_" + In19 + "_" + lChildOrigID.get(i) + "_" + dateString + "_" + doc.field[Const.gDDF_AKTIVITAETSID] + ".d3l")
|
|
File lPathJPL = new File("F:\\d3\\Hostimport\\LinkFiles\\CopyECR" + "_" + In19 + "_" + lChildOrigID.get(i) + "_" + dateString + "_" + doc.field[Const.gDDF_AKTIVITAETSID] + ".jpl")
|
|
|
|
lPathJPL.write("logi_verzeichnis = \"Fr\"" + System.lineSeparator())
|
|
lPathJPL.append("dokuart = '${Const.gDTS_DMECR}'" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_BESCHREIBUNG}] = \"" + checkValueForJpl(In24) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ERGEBNISDOK}] = \"" + checkValueForJpl(In44) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_BUCHKREIS}] = \"" + checkValueForJpl(In28) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOCINFONR}] = \"" + checkValueForJpl(In80) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"" + checkValueForJpl(In21) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGRP}] = \"" + checkValueForJpl(In18) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKTITLE}] = \"" + checkValueForJpl(In17) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ECRSTATUS}] = \"" + checkValueForJpl(In43) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_JAHR}] = \"" + checkValueForJpl(In33) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KNAME}] = \"" + checkValueForJpl(In23) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_KNR}] = \"" + checkValueForJpl(In22) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_MONAT}] = \"" + checkValueForJpl(In34) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_PROJKLAMMER}] = \"" + checkValueForJpl(In8) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_AUFTRNR}] = \"" + checkValueForJpl(In19) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_PROZESS}] = \"" + checkValueForJpl(In5) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_PSPELEMENT}] = \"" + checkValueForJpl(In2) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_STATUS}] = \"" + checkValueForJpl(In1) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_SUBMISSION}] = \"" + checkValueForJpl(In37) + "\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_AKTIVITAETSID}] = \"" + checkValueForJpl(In15) + "\"" + System.lineSeparator())
|
|
|
|
// Der Hostimport erwartet ein bestimmtes Format, daher muss der Timestamp angepasst werden
|
|
Date date50 = new Date(In50.getTime());
|
|
SimpleDateFormat sdf50 = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
|
|
String formatDateTime50 = sdf50.format(date50);
|
|
formatDateTime50 = formatDateTime50.replace(":", "\\:")
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ERDATE}] = \"" + formatDateTime50 + "\"" + System.lineSeparator())
|
|
|
|
lPathJPL.append("text[4] = \"" + lChildOrigID.get(i) + "\"" + System.lineSeparator())
|
|
|
|
for(int lCount=1; lCount <= lErgDocCount; i++) {
|
|
lPathJPL.append("dok_dat_feld_${Const.gDDF_ERGDOCFUER[lCount]} = \"" + lErgDoc60.get(lCount) + "\"" + System.lineSeparator())
|
|
}
|
|
|
|
lPathD3L.write("idlist" + System.lineSeparator())
|
|
lPathD3L.append("${lChildOrigID.get(i)}")
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Erstelle für alle Einkauf Nummern im 60er Feld (BelegNr) eine D3L-Datei für den Hostimport
|
|
* @author Einkauf
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund wird eine D3L-Datei erstellt
|
|
*/
|
|
public static void createLinkFilesPurchase( D3Interface d3, Document doc, def lBelegNr ) {
|
|
d3.log.info("Start Functions createLinkFilesPurchase");
|
|
|
|
if(doc.getFileExtension() != null && !doc.getFileExtension().equals("d3l") && !doc.getFileExtension().equals("D3L")) {
|
|
|
|
d3.log.info("Funktion createLinkFilesPurchase wurde gestartet!")
|
|
|
|
def doc_type_short = doc.getType().getId()
|
|
|
|
def date = new Date()
|
|
def sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS")
|
|
def lKey = sdf.format(date).toString()
|
|
|
|
// Prüfung der Dokumenteigenschaften auf Null-Values
|
|
def lDokGroup = checkIfNullValue(doc.field[Const.gDDF_DOKGROUP]);
|
|
def lDocTitle = checkIfNullValue(doc.field[Const.gDDF_DOKTITLE]);
|
|
def lERDate = doc.field[Const.gDDF_ERDATE];
|
|
def lProcType = checkIfNullValue(doc.field[Const.gDDF_PROZESS]);
|
|
lBelegNr = checkIfNullValue(lBelegNr);
|
|
|
|
def lCustName
|
|
def lCustNo
|
|
|
|
File lPathJPL = new File( "F:\\d3\\Hostimport\\LinkFiles\\" + doc.id() + "_" + lKey + "_" + lBelegNr + "_" + doc_type_short + ".jpl" )
|
|
|
|
if( lBelegNr != null && !lBelegNr.equals("") ) {
|
|
def sqlStatement = "SELECT ISNULL(dok_dat_feld_${Const.gDDF_KNAME}, '') as lCustName, ISNULL(dok_dat_feld_${Const.gDDF_KNR}, '') as lCustNo " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AEIBE}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${lBelegNr}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if( sqlResult != null && sqlResult.size() > 0 ) {
|
|
lCustName = sqlResult.getAt(0).get("lCustName")
|
|
lCustNo = sqlResult.getAt(0).get("lCustNo")
|
|
}
|
|
}
|
|
|
|
try {
|
|
|
|
// Allgemein Attribute
|
|
lPathJPL.append("logi_verzeichnis = \"Fr\"" + System.lineSeparator())
|
|
lPathJPL.append("dokuart = \"${doc_type_short}\"" + System.lineSeparator())
|
|
lPathJPL.append("text[3] = \"${doc.id()}\"" + System.lineSeparator())
|
|
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"${checkValueForJpl(lDokGroup)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_DOKTITLE}] = \"${checkValueForJpl(lDocTitle)}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_ERDATE}] = \"${lERDate}\"" + System.lineSeparator())
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_PROZESS}] = \"${checkValueForJpl(lProcType)}\"" + System.lineSeparator())
|
|
|
|
// Pflichtfelder
|
|
lPathJPL.append("dok_dat_feld[${Const.gDDF_BELEGNUMMER}] = \"${checkValueForJpl(lBelegNr)}\"" + System.lineSeparator())
|
|
|
|
File lPathD3L = new File( "F:\\d3\\Hostimport\\LinkFiles\\" + doc.id() + "_" + lKey + "_" + lBelegNr + "_" + doc_type_short + ".d3l" )
|
|
lPathD3L.append("idlist" + System.lineSeparator())
|
|
lPathD3L.append(doc.id())
|
|
|
|
} catch(Exception e) {
|
|
d3.log.error("Die D3L Datei für Beleg Nummer ${lBelegNr} mit Bezug auf Dokument ${doc.id()} konnte nicht erstellt werden! Errorcode = " + e )
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Erstelle Marktbeobachtungsakten
|
|
* @author Unterstützende Prozesse
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund werden Akten erstellt
|
|
*/
|
|
public static void createMarketResearchFolder(D3Interface d3, Document doc, def lMarketingProjekt) {
|
|
d3.log.info("Start Functions createMarketResearchFolder");
|
|
|
|
def lReturnvalue //Fehlercode
|
|
def lDocIdTmp
|
|
|
|
//Definition der Marketingprojekt Phasen
|
|
List<String> lProjektphasen = new ArrayList<>();
|
|
lProjektphasen.add("01 Anfrage I Briefing")
|
|
lProjektphasen.add("02 Analyse")
|
|
lProjektphasen.add("03 Bereitstellung")
|
|
|
|
for(int j=0; j < lProjektphasen.size(); j++) {
|
|
Document newDoc = d3.archive.newDocument()
|
|
newDoc.type = Const.gDTS_AUNMA
|
|
newDoc.status = "Freigabe"
|
|
if(lMarketingProjekt != null) {
|
|
newDoc.field[Const.gDDF_MARKETINGPROJEKT]= lMarketingProjekt
|
|
}
|
|
if(lProjektphasen != null && lProjektphasen.get(j) != null) {
|
|
newDoc.field[Const.gDDF_PROJEKTPHASE] = lProjektphasen.get(j)
|
|
}
|
|
newDoc.field[Const.gDDF_PROZESS] = "PZ001" //Marktforschungsprojekte
|
|
lReturnvalue = d3.call.folder_create(newDoc)
|
|
if(lReturnvalue != null && lReturnvalue != 0) {
|
|
d3.log.error("### Fehler folder_create Bauakte (createMarketResearchFolder) ${lReturnvalue}")
|
|
}
|
|
}
|
|
} //Ende createMarketResearchFolder
|
|
|
|
/**
|
|
* Erstelle eine neue Angebotsakte, wenn das Attribut "neues Angebot" auf Ja gesetzt wird
|
|
* @author
|
|
* @see UpdateAttributExit
|
|
* @return Rückgabe neuer Dokument-Id
|
|
*/
|
|
public static String createNewOffer( D3Interface d3, Document doc ) {
|
|
d3.log.info("Start Functions createNewOffer");
|
|
|
|
def lReturn
|
|
def lFatherOpp
|
|
def lANNrTemp
|
|
def lANNrCompare
|
|
def lANNrMax
|
|
String lTimeStamp
|
|
def lANLength
|
|
def lANShort
|
|
def lANShortLength
|
|
|
|
Document docTemp = d3.archive.getDocument( doc.id() )
|
|
|
|
def date = new Date()
|
|
// JPL -> lTimeStamp = sm_sdtime("n%4y%0m%d%h%M%0s") -> Beispiel 2017083111415
|
|
def sdf = new SimpleDateFormat("yyyyMMddHHmmss")
|
|
lTimeStamp = sdf.format(date).toString()
|
|
|
|
//Frage zunächst die Dok-ID des Vaterdokuments ab und setze eine Variable
|
|
String[] parents = d3.call.link_get_parents( doc.id(), "d3groovy")
|
|
lReturn = parents.size()
|
|
|
|
if( lReturn > 0 ) {
|
|
lFatherOpp = parents[0]
|
|
d3.log.info("Die Vaterakte lautet :lFatherOpp")
|
|
} else {
|
|
d3.log.error("Der Elementarprozess zu Dokument :doku_id_ref konnte nicht ermittelt werden! Errorcode ${lReturn}")
|
|
}
|
|
|
|
Document docNew = d3.archive.newDocument();
|
|
|
|
//Übernehme die Attribute des bisherigen Angebots und setze Sie für die Neuanlage
|
|
// dkle, 02.02.2016 Die Angebotsversion enthält kein Ereignisdatum mehr, auskommentiert
|
|
if( lReturn > 0 ) {
|
|
def lKdNr = doc.field[Const.gDDF_KNR]
|
|
def lKdName = doc.field[Const.gDDF_KNAME]
|
|
def lProz = doc.field[Const.gDDF_PROZESS]
|
|
def lOppNR = doc.field[Const.gDDF_OPPNUMMER]
|
|
def lHauptOpp = doc.field[Const.gDDF_HAUPTOPP]
|
|
def lSubMis = doc.field[Const.gDDF_SUBMISSION]
|
|
def lJahr = doc.field[Const.gDDF_JAHR]
|
|
def lMonat = doc.field[Const.gDDF_MONAT]
|
|
def lBuchungskreis = doc.field[Const.gDDF_BUCHKREIS]
|
|
def lAngebot = doc.field[Const.gDDF_ANNAME]
|
|
String lANNummer = doc.field[Const.gDDF_OPPANNr]
|
|
def lANStatus = doc.field[Const.gDDF_ANSTATUS]
|
|
def lANNeu = doc.field[Const.gDDF_ANNEU]
|
|
def lOppState = doc.field[Const.gDDF_STATUS]
|
|
def lSalesGroup = doc.field[Const.gDDF_SALESGROUP]
|
|
def lANNummerAlt = doc.field[Const.gDDF_OPPANNr]
|
|
|
|
docNew.type = Const.gDTS_AREGI
|
|
docNew.status = Document.DocStatus.DOC_STAT_RELEASE // "Freigabe"
|
|
docNew.field[Const.gDDF_KNR] = lKdNr
|
|
docNew.field[Const.gDDF_KNAME] = lKdName
|
|
docNew.field[Const.gDDF_PROZESS] = lProz
|
|
docNew.field[Const.gDDF_OPPNUMMER] = lOppNR
|
|
docNew.field[Const.gDDF_HAUPTOPP] = lHauptOpp
|
|
docNew.field[Const.gDDF_SUBMISSION] = lSubMis
|
|
docNew.field[Const.gDDF_JAHR] = lJahr
|
|
docNew.field[Const.gDDF_MONAT] = lMonat
|
|
docNew.field[Const.gDDF_BUCHKREIS] = lBuchungskreis
|
|
docNew.field[Const.gDDF_ANNAME] = lAngebot
|
|
docNew.field[Const.gDDF_ANSTATUS] = "in Arbeit"
|
|
docNew.field[Const.gDDF_ANNEU] = "Nein"
|
|
docNew.field[Const.gDDF_STATUS] = lOppState
|
|
docNew.field[Const.gDDF_SALESGROUP] = lSalesGroup
|
|
|
|
//Prüfe, ob die Angebotsnummer eine SAP- oder ein Platzhalterangebotsnummer ist...
|
|
lANNrCompare = lANNummer.substring(0,4)
|
|
|
|
//... wenn Platzhalter, dann erhöhe die Angebotsnummer um 1
|
|
if( lANNrCompare.equals("Neue") ) {
|
|
|
|
String[] splittedString = lANNummer.split(" ");
|
|
def anNumber = splittedString[2];
|
|
//Erhöhe die Angebotsnummer um 1
|
|
try {
|
|
anNumber = anNumber.trim()
|
|
anNumber = Integer.valueOf(anNumber)
|
|
anNumber = anNumber + 1
|
|
lANNrTemp = anNumber
|
|
} catch(Exception e) {
|
|
d3.log.error("createNewOffer # lANShort enthält keinen Integer-Wert")
|
|
}
|
|
|
|
lANNummer = "Neue Angebotsversion ${lANNrTemp} ${lTimeStamp}"
|
|
|
|
docNew.field[Const.gDDF_OPPANNr] = lANNummer
|
|
|
|
// 19.11.2015/dkle Kommentar hinter das else kopiert... wenn SAP-Nummer hole die höchste Platzhalternummer und erhöhe diese um 1
|
|
} else {
|
|
def sqlStatement = "SELECT max(dok_dat_feld_${Const.gDDF_OPPANNr}) as lANNrMax " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNR}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_ANNAME} = '${lAngebot}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_OPPANNr} like 'Neue %' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AREGI}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
lANNrMax = sqlResult.getAt(0).get("lANNrMax")
|
|
|
|
if( lANNrMax != null && !lANNrMax.equals("") ) {
|
|
lANLength = lANNrMax.length()
|
|
lANShortLength = lANLength - 14
|
|
lANShort = lANNrMax.substring(0, lANShortLength)
|
|
def anNumber = lANShort.substring(21, lANShort.length())
|
|
//Erhöhe die Angebotsnummer um 1
|
|
try {
|
|
anNumber = anNumber.trim()
|
|
anNumber = Integer.valueOf(anNumber)
|
|
anNumber = anNumber + 1
|
|
lANNrTemp = anNumber
|
|
} catch(Exception e) {
|
|
d3.log.error("createNewOffer # lANShort enthält keinen Integer-Wert")
|
|
}
|
|
|
|
lANNummer = "Neue Angebotsversion ${lANNrTemp} ${lTimeStamp}"
|
|
} else {
|
|
lANNummer = "Neue Angebotsversion 1 ${lTimeStamp}"
|
|
}
|
|
|
|
docNew.field[Const.gDDF_OPPANNr] = lANNummer
|
|
}
|
|
|
|
lReturn = d3.call.folder_create( docNew )
|
|
String newDokuId
|
|
|
|
if(lReturn == 0) {
|
|
|
|
def sqlStatementNewDocId = "SELECT doku_id as dokuId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_AREGI}' AND dok_dat_feld_${Const.gDDF_OPPANNr} = '${lANNummer}'"
|
|
List<GroovyRowResult> sqlResultNewDocId = d3.sql.executeAndGet(sqlStatementNewDocId)
|
|
|
|
newDokuId = sqlResultNewDocId.getAt(0).get("dokuId")
|
|
|
|
if( newDokuId != null ) {
|
|
docNew = d3.archive.getDocument(newDokuId);
|
|
|
|
d3.log.info("Die Angebotsakte ${docNew.id()} wurde erfolgreich angelegt!")
|
|
|
|
lReturn = d3.call.link_documents(lFatherOpp, docNew.id(), "d3groovy", false, false)
|
|
|
|
if( lReturn == 0 ) {
|
|
d3.log.info("Die Aktenverknüpfung zwischen Angebotsakte ${docNew.id()} und Elementarprozessakte ${lFatherOpp} wurde erfolgreich angelegt!")
|
|
} else {
|
|
d3.log.error("Die Aktenverknüpfung zwischen Angebotsakte ${docNew.id()} und Elementarprozessakte ${lFatherOpp} wurde nicht erfolgreich angelegt! Errorcode :lReturn")
|
|
}
|
|
|
|
doc.field[Const.gDDF_ANNEU] = "Nein"
|
|
doc.field[Const.gDDF_ANSTATUS] = "geschlossen"
|
|
try {
|
|
doc.updateAttributes("d3groovy")
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
}
|
|
|
|
// in JPL waren die Parameter alle geleert, daher immer default verwenden
|
|
d3.call.document_send_to_dsearch( doc.id(), "", 0, "", false, "Fr", 0, "d3groovy")
|
|
}
|
|
}
|
|
|
|
def lDocIdAnNeu = newDokuId;
|
|
doc.field[Const.gDDF_OPPANNr] = docTemp.field[Const.gDDF_OPPANNr]
|
|
|
|
return "${lDocIdAnNeu}"
|
|
|
|
} else {
|
|
d3.log.error("Der Dokumentkontext für die Anlage einer Angebotsakte konnte nicht geladen werden!")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Wenn initial in der Inquiry Akte Einträge in Angebotsnamen gemacht werden, erstelle neue Elementarprozessakten (02 Angebot) und darunter jeweils neue Angebotsakten
|
|
* @author
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund werden Akten erstellt
|
|
*/
|
|
public static void createOfferFolder(D3Interface d3, Document doc, def doc_type_short ) {
|
|
d3.log.info("Start Functions createOfferFolder");
|
|
|
|
//Setze Variablen zur Übernahme der Attribute auf die untergeordneten Akten
|
|
// dkle, 02.02.2016 Die Opportunityakten enthelten kein Ereignisdatum mehr, auskommentiert
|
|
def h_folder_doku_id
|
|
def h_folder_exist
|
|
def h_folder_name
|
|
def tmp_kundeName = doc.field[Const.gDDF_KNAME]
|
|
def tmp_KundeNr = doc.field[Const.gDDF_KNR]
|
|
def tmp_BuchKr = doc.field[Const.gDDF_BUCHKREIS]
|
|
def tmp_prozess = doc.field[Const.gDDF_PROZESS]
|
|
def tmp_Angebot = doc.field[Const.gDDF_ANNAME]
|
|
def tmp_OppNr = doc.field[Const.gDDF_OPPNUMMER]
|
|
def tmp_HauptOpp = doc.field[Const.gDDF_HAUPTOPP]
|
|
def tmp_Submiss = doc.field[Const.gDDF_SUBMISSION]
|
|
def tmp_Status = doc.field[Const.gDDF_STATUS]
|
|
def tmp_SalesGroup = doc.field[Const.gDDF_SALESGROUP]
|
|
def tmp_MultVal
|
|
List<String> tmp_Angebote = new ArrayList<>();
|
|
List<String> tmp_Intercompany = new ArrayList<>();
|
|
|
|
Date dateOffer = new Date();
|
|
SimpleDateFormat sdfOffer = new SimpleDateFormat("yyyyMMddHHmmss");
|
|
String dateString = sdfOffer.format(dateOffer);
|
|
|
|
// imue 22.11.2021: Generierung Zeitstempel um Angebotsvorgang mit Angebotsversion verbinden zu können!
|
|
String lOPPANNrMain = "Neues Angebot " + dateString
|
|
try {
|
|
Document docFolderVorgang = d3.archive.getDocument(doc.id());
|
|
docFolderVorgang.field[Const.gDDF_HAUPTOPPANNR] = lOPPANNrMain;
|
|
docFolderVorgang.updateAttributes("d3groovy", true)
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false);
|
|
}
|
|
|
|
// imue 15.04.2019 - OPG-2132 - Vererbung "Intercompany"
|
|
for(int i = 1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
//Setze die neuen Angebotsnamen in ein Array
|
|
if( doc.field[Const.gDDF_BUCHKREIS68][i] != null && !doc.field[Const.gDDF_BUCHKREIS68][i].equals("") ) {
|
|
tmp_Intercompany.add(doc.field[Const.gDDF_BUCHKREIS68][i]);
|
|
}
|
|
}
|
|
|
|
// Achtung!: 60er Feld beginnt bei 1 aber Array bei 0!
|
|
if(tmp_Intercompany != null && tmp_Intercompany.size() > 0) {
|
|
for(int j=1; j <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); j++) {
|
|
if(j <= tmp_Intercompany.size() ) {
|
|
if( tmp_Intercompany.get(j-1) != null && !tmp_Intercompany.get(j-1).equals("") ) {
|
|
doc.field[Const.gDDF_BUCHKREIS68][j] = tmp_Intercompany.get(j-1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Hole jetzt die Attribute der neuen Akte
|
|
String newOfferVers = "Neue Angebotsversion 1 ${dateString}";
|
|
Document newDoc = d3.archive.newDocument();
|
|
newDoc.type = Const.gDTS_AREGI
|
|
newDoc.field[Const.gDDF_ANNAME] = tmp_Angebot
|
|
newDoc.field[Const.gDDF_OPPNUMMER] = tmp_OppNr
|
|
newDoc.field[Const.gDDF_OPPANNr] = newOfferVers;
|
|
newDoc.field[Const.gDDF_ANNEU] = "Nein"
|
|
newDoc.field[Const.gDDF_ANSTATUS] = "in Arbeit"
|
|
newDoc.field[Const.gDDF_STATUS] = tmp_Status
|
|
newDoc.status = "Freigabe"
|
|
|
|
// 19.11.2015/dkle neue Attribute für die Angebotsversionsakte, vorher durch Aktenplan
|
|
newDoc.field[Const.gDDF_KNR] = tmp_KundeNr
|
|
newDoc.field[Const.gDDF_SUBMISSION] = tmp_Submiss
|
|
newDoc.field[Const.gDDF_HAUPTOPP] = tmp_HauptOpp
|
|
newDoc.field[Const.gDDF_BUCHKREIS] = tmp_BuchKr
|
|
newDoc.field[Const.gDDF_KNAME] = tmp_kundeName
|
|
newDoc.field[Const.gDDF_PROZESS] = tmp_prozess
|
|
newDoc.field[Const.gDDF_SALESGROUP] = tmp_SalesGroup
|
|
|
|
Document docAfterImport = d3.archive.importDocument(newDoc);
|
|
if(docAfterImport != null) {
|
|
// wenn Aktenerstellung erfolgreich
|
|
h_folder_doku_id = docAfterImport.id();
|
|
d3.log.info("Die Angebotsversion zur Opportunity ${tmp_OppNr} wurde mit der Nummer ${h_folder_doku_id} erfolgreich angelegt!")
|
|
|
|
def lOffDocID
|
|
def lReturn
|
|
def lOPPANNr = newDoc.field[Const.gDDF_OPPANNr]
|
|
|
|
docAfterImport.field[Const.gDDF_HAUPTOPPANNR] = lOPPANNrMain
|
|
try {
|
|
docAfterImport.updateAttributes("d3groovy", true)
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, h_folder_doku_id, null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false);
|
|
}
|
|
|
|
d3.call.document_send_to_dsearch( doc.id(), "", 0, "", false, "Fr", 0, "d3groovy");
|
|
|
|
// 19.11.2015/dkle Verlinkung der neuen Angebotsversionsakte (api_doc_id - Child) mit der Angebotsvorgangsakte (doku_id_ref - Father)
|
|
d3.call.link_documents(doc.id(), docAfterImport.id(), "d3groovy", false, false);
|
|
} else {
|
|
d3.log.error("Die Angebotsversion zur Opportunity ${tmp_OppNr} wurde nicht erfolgreich angelegt!");
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Erstellung einer HTML Datei für Wissens- oder Infothekdokumente, damit eine Suchseite für d3one zur Verfügung steht
|
|
* @author Unterstützende Prozesse
|
|
* @see InsertExit, UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund wird eine HTML Datei erstelllt
|
|
*/
|
|
public static void createSearchHTML( D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions createSearchHTML");
|
|
|
|
List<String> lValue = new ArrayList<>()
|
|
def lDDFNo
|
|
def lField
|
|
def lOne
|
|
def lCnt
|
|
def lParseString
|
|
def lRetVal
|
|
def lCount
|
|
def lArraySum
|
|
def lArrayDDF
|
|
def lArrayField
|
|
def lArrayOne
|
|
File lOrgFile
|
|
File lFile
|
|
|
|
if( doc.getType().getId().equals(Const.gDTS_DSCHU) ) {
|
|
|
|
//Pfad zur Originaldatei, die als Quelle dient
|
|
lOrgFile = new File("E:\\d3\\d3work\\Schulungsdokumentation\\orgfile.html")
|
|
|
|
//Pfad zur Datei, bei der Zeilen angefügt werden sollen
|
|
String filePath = "\\\\sde01d3t06\\c\$\\inetpub\\wwwroot\\optima\\sucheschulungattr.html"
|
|
lFile = new File(filePath)
|
|
//File lFile = "E\:\\d3\\d3work\\Schulungsdokumentation\\sucheschulungattr.html"
|
|
|
|
|
|
//Arrays mit den DDF und Werten, für die eine Suche erstellt werden soll. Immer auf die Beziehungen untereinander achten
|
|
lArrayDDF = "60"
|
|
lArrayField = ""
|
|
lArrayOne = "%7B%22210%22%3A%5B%22"
|
|
|
|
String[] splittedString = lArrayDDF.split(";")
|
|
lArraySum = splittedString.size()
|
|
|
|
if( lFile.exists() && !lFile.isDirectory() ) {
|
|
lRetVal = 1
|
|
} else {
|
|
lRetVal = 0
|
|
}
|
|
|
|
}
|
|
|
|
if( doc.getType().getId().equals(Const.gDTS_DWISS)) {
|
|
|
|
//Pfad zur Originaldatei, die als Quelle dient
|
|
lOrgFile = new File("E:\\d3\\d3work\\Schulungsdokumentation\\orgfileDWISS.html");
|
|
|
|
//Pfad zur Datei, bei der Zeilen angefügt werden sollen
|
|
String filePath = "\\\\sde01d3t06\\c\$\\inetpub\\wwwroot\\optima\\sucheswissenattr.html"
|
|
lFile = new File(filePath);
|
|
//File lFile = "E\:\\d3\\d3work\\Schulungsdokumentation\\sucheschulungattr.html"
|
|
|
|
|
|
//Arrays mit den DDF und Werten, für die eine Suche erstellt werden soll. Immer auf die Beziehungen untereinander achten
|
|
lArrayDDF = "48;61;68"
|
|
lArrayField = "Trends;Region;Business Unit"
|
|
lArrayOne = "%7B%22125%22%3A%5B%22;%7B%22116%22%3A%5B%22;%7B%22125%22%3A%5B%22"
|
|
|
|
String[] splittedString = lArrayDDF.split(";")
|
|
lArraySum = splittedString.size()
|
|
|
|
if( lFile.exists() && !lFile.isDirectory() ) {
|
|
lRetVal = 1
|
|
} else {
|
|
lRetVal = 0
|
|
}
|
|
|
|
}
|
|
|
|
//Nur wenn die Zieldatei existiert ausführen
|
|
if( lRetVal == 1 ) {
|
|
|
|
copyFileUsingStream(lOrgFile, lFile)
|
|
|
|
for( int i=0; i < lArraySum; i++ ) {
|
|
String[] splittedString1 = lArrayDDF.split(";")
|
|
lDDFNo = splittedString1[i].trim()
|
|
|
|
String[] splittedString2 = lArrayField.split(";")
|
|
lField = splittedString2[i].trim()
|
|
|
|
String[] splittedString3 = lArrayOne.split(";")
|
|
lOne = splittedString3[i].trim()
|
|
|
|
if( Integer.valueOf(lDDFNo) <= 59 || Integer.valueOf(lDDFNo) >= 70 ) {
|
|
|
|
def sqlStatement = "SELECT DISTINCT dok_dat_feld_${lDDFNo} as lValue " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${doc.getType().getId()}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
def newValue = grr.get("lValue");
|
|
newValue = StringEscapeUtils.escapeHtml(newValue);
|
|
lValue.add(newValue);
|
|
}
|
|
lCnt = sqlResult.size()
|
|
|
|
//HTML Code anfügen
|
|
for(int j=0; j < lCnt; j++) {
|
|
if( !lValue.get(j).equals("") ) {
|
|
def sqlStatementSec = "SELECT * " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${doc.getType().getId()}' " +
|
|
"AND dok_dat_feld_${lDDFNo} = '${lValue.get(j)}' "
|
|
|
|
List<GroovyRowResult> sqlResultSec = d3.sql.executeAndGet(sqlStatementSec)
|
|
lCount = sqlResultSec.size()
|
|
|
|
lParseString = "<option value=\"${lOne}"
|
|
lParseString = lParseString + "${lValue.get(j)}\">${lField} ${lValue.get(j)} (${lCount})</option>"
|
|
lFile << lParseString + "\n"
|
|
}
|
|
|
|
}
|
|
} else {
|
|
def sqlStatement = "select distinct value_char as lValue " +
|
|
"from firm_spez_mult_val " +
|
|
"where field_no = '${lDDFNo}' " +
|
|
"and doku_id in (select doku_id from firmen_spezifisch where kue_dokuart = '${doc.getType().getId()}') "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
def newValue = grr.get("lValue");
|
|
newValue = StringEscapeUtils.escapeHtml(newValue);
|
|
lValue.add(newValue);
|
|
}
|
|
lCnt = sqlResult.size()
|
|
|
|
//HTML Code anfügen
|
|
for(int j=0; j < lCnt; j++) {
|
|
if( lValue.get(j) != null && !lValue.get(j).equals("") ) {
|
|
def sqlStatementSec = "select value_char " +
|
|
"from firm_spez_mult_val " +
|
|
"where field_no = '${lDDFNo}' " +
|
|
"and value_char = '${lValue.get(j)}' " +
|
|
"and doku_id in (select doku_id from firmen_spezifisch where kue_dokuart = '${doc.getType().getId()}') "
|
|
|
|
List<GroovyRowResult> sqlResultSec = d3.sql.executeAndGet(sqlStatementSec)
|
|
lCount = sqlResultSec.size()
|
|
|
|
lParseString = "<option value=\"${lOne}"
|
|
lParseString = lParseString + lValue.get(j) + "\">" + lField + lValue.get(j) + " (" + lCount + ")</option>"
|
|
lFile << lParseString + "\n"
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
lFile << "</select>" + "\n"
|
|
lFile << "<button>Anwenden</button>" + "\n"
|
|
lFile << "</label>" + "\n"
|
|
lFile << "</div>" + "\n"
|
|
lFile << "</form>" + "\n"
|
|
lFile << "</body>" + "\n"
|
|
lFile << "</html>" + "\n"
|
|
|
|
} else {
|
|
d3.log.error("Datei nicht vorhanden :lFile")
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Erstellung eines UPD Async Jobs zur Aktualisierung von Dokumenten über den d.3 Async (UPD001)
|
|
* Voraussetzung: d3config -> ASYNC_JOB_TYPE = CUSTOMJOB
|
|
* @author Hilfsfunktion
|
|
* @return keine Rückgabe; im Hintergrund werden Async Jobs erstellt
|
|
*/
|
|
public static void createAsyncJobForUpdates(D3Interface d3, Document docTrigger, List<String> docIdsToUpdate, Map<Integer, Object> attributesUpdate, String functionName) {
|
|
d3.log.info("Start Functions createAsyncJobForUpdates with <${functionName}>");
|
|
|
|
// Wenn keine JPL Lösung gefunden wurde, dann nehme den Asynchronen Standardweg
|
|
for(String docId : docIdsToUpdate) {
|
|
try {
|
|
// Quelle Dokumentation:
|
|
// Die Job-Parameterangaben, die in der Spalte Dokumentart auf eine "-200" verweisen, sind die Suchangaben zur Identifikation des Dokumentes im d.3 Repository.
|
|
// Die Job-Parameterangaben, die in der Spalte Dokumentart auf eine "200" verweisen, sind die Zielangaben, auf die das ermittelte Dokument upgedatet werden soll.
|
|
d3.call.d3async_job_open(docId, "UPD001", "d3groovy");
|
|
// eindeutige Erkennungseigenschaften "o_"
|
|
d3.call.d3async_job_set_attribute("doku_id", docId, -200);
|
|
// neue Eigenschaften "n_" (neue Werte aus der Vaterakte)
|
|
if(attributesUpdate != null && attributesUpdate.size() > 0) {
|
|
for(int ddf : attributesUpdate.keySet()) {
|
|
if(ddf > 59 && ddf < 70) {
|
|
// Mehrfachfeld (60-69)
|
|
try {
|
|
List<String> attributValues = attributesUpdate.get(ddf);
|
|
for(int i = 1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
String value = attributValues.get(i-1).toString();
|
|
if(value == null || (value != null && value.equals("null"))) {
|
|
value = "";
|
|
}
|
|
d3.call.d3async_job_set_attribute("dok_dat_feld_${ddf}[${i}]", value, 200);
|
|
}
|
|
} catch(Exception e2) {
|
|
d3.log.error("Fehler bei Zugriff auf Mehrfachfeld = " + e2);
|
|
}
|
|
} else {
|
|
// Einfachfeld
|
|
String value = attributesUpdate.get(ddf).toString();
|
|
if(value == null || (value != null && value.equals("null"))) {
|
|
value = "";
|
|
}
|
|
d3.call.d3async_job_set_attribute("dok_dat_feld_${ddf}", value, 200);
|
|
}
|
|
}
|
|
}
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Datei konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, docId, null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Datei für Dokument ${docId} konnte nicht erstellt werden = " + e);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Erstellung einer Dublette aller Ergebnisdokumente
|
|
* @author
|
|
* @see InsertExit, UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund werden Dokumente erstellt
|
|
*/
|
|
public static void copyApprovedECR( D3Interface d3, def lActID, def lOrderID, def lDirectCopy ) {
|
|
d3.log.info("Start Functions copyApprovedECR");
|
|
|
|
def lReturn
|
|
List<String> lDocIDResultDoc = new ArrayList<>();
|
|
def lDocIDResultDocCount
|
|
|
|
if( lDirectCopy.equals("") ) {
|
|
|
|
// phoer 05.10.2016: Suche alle ECR-Dokumente im Auftrag, die eine Aktivitäts-ID und das Ergebnisdokument = Ja haben
|
|
def sqlStatement = "SELECT doku_id as lDocIDResultDoc " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_DMECR}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lOrderID}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_AKTIVITAETSID} = '${lActID}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_ERGEBNISDOK} = 'Ja' ";
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement);
|
|
if(sqlResult != null && sqlResult.size()> 0) {
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
lDocIDResultDoc.add(grr.get("lDocIDResultDoc"))
|
|
}
|
|
lDocIDResultDocCount = sqlResult.size()
|
|
}
|
|
|
|
} else {
|
|
lDocIDResultDoc.add(lDirectCopy)
|
|
lDocIDResultDocCount = 1
|
|
d3.log.info( "lDocIDResultDoc[0]: ${lDocIDResultDoc.get(0)} - lDocIDResultDocCount: ${lDocIDResultDocCount}" )
|
|
}
|
|
|
|
for(int i=0; i < lDocIDResultDocCount; i++) {
|
|
|
|
// Eigenschaften des Original Dokumentes holen
|
|
Document originalDoc = d3.archive.getDocument(lDocIDResultDoc.get(i), "d3groovy")
|
|
|
|
// Ermittlung Filepath im Dokbaum - daher vorher Prüfung notwendig ob Dokument sich auf dem Storage befindet
|
|
String filepath
|
|
def sqlStatement = "SELECT fd.lokalisation as lokalisation FROM files_datentraeger as fd WHERE fd.doku_id NOT LIKE '\$%' AND doku_id = '${lDocIDResultDoc[i]}'"
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
def originalDocLocalisation = sqlResult.getAt(0).get("lokalisation")
|
|
if( originalDocLocalisation == 2 ) {
|
|
// Dokument befindet sich auf dem Storage und muss vor Ermittlung "zurückgeholt" werden
|
|
// Optima hat kein Storage im Einsatz, daher keine Relevanz
|
|
} else {
|
|
filepath = d3.call.document_get_file_path( lDocIDResultDoc[i], "Fr", originalDoc.getFileIdCurrentVersion(), "d3groovy", "")
|
|
}
|
|
|
|
// nur wenn filepath nicht leer ist, kann das Dokument kopiert werden
|
|
if(filepath != null && !filepath.equals("")) {
|
|
|
|
// Akte (48) -> wird automatisch auf Werkauftrag gesetzt
|
|
// Feld Akte -> Dokumenttitel
|
|
// Auftragsnummer (19), Bemerkung (9), Buchungskreis (28), Dokumenteninfosatz Nr. (80), Dokumentgruppe (21), Dokumentkategorie (18), Ereignisdatum (50),
|
|
// Ergebnisdokument (60), Hauptauftrag (8), Jahr (33), Kunden_Name (23), Kunden_Nr (22), Monat (34), Prozessart (5), Prozessgruppe (4), weitere Auftragsnummern (66)
|
|
|
|
// Workaround: Datei temporär lokal verarbeiten aufgrund der FileExtension
|
|
File fileTemp = new File(filepath)
|
|
def docName = originalDoc.getFilename()
|
|
// Sonderzeichen entfernen
|
|
docName = docName.replaceAll("[\\\\/:*?\"<>|]", "_");
|
|
def docExt = originalDoc.getFileExtension()
|
|
String copiedFileDest = copyDocumentUsingChannel(d3, fileTemp, docName, docExt)
|
|
|
|
if(copiedFileDest != null && !copiedFileDest.equals("") ) {
|
|
|
|
Path importFile = Paths.get(copiedFileDest);
|
|
|
|
// Neues Dokument definieren mit Eigenschaften des Originals
|
|
Document newDoc = d3.archive.newDocument();
|
|
newDoc.type = Const.gDTS_DMSPE
|
|
newDoc.status = Document.DocStatus.DOC_STAT_RELEASE
|
|
newDoc.setText(3, "${lDocIDResultDoc[i]}")
|
|
newDoc.setText(4, "ECR cloned")
|
|
newDoc.field[Const.gDDF_SUBJECT]= Const.gAK_Werkauftrag
|
|
newDoc.field[Const.gDDF_DOKTITLE] = originalDoc.field[Const.gDDF_DOKTITLE]
|
|
newDoc.field[Const.gDDF_AUFTRNR] = originalDoc.field[Const.gDDF_AUFTRNR]
|
|
String tempInt = originalDoc.field[Const.gDDF_DOCINFONR]
|
|
newDoc.field[Const.gDDF_DOCINFONR] = originalDoc.field[Const.gDDF_DOCINFONR]
|
|
newDoc.field[Const.gDDF_DOKGROUP] = Const.gDG_ECRChangeOrder
|
|
newDoc.field[Const.gDDF_ERDATE] = originalDoc.field[Const.gDDF_ERDATE]
|
|
newDoc.field[Const.gDDF_JAHR] = originalDoc.field[Const.gDDF_JAHR]
|
|
newDoc.field[Const.gDDF_MONAT] = originalDoc.field[Const.gDDF_MONAT]
|
|
|
|
// Mehrfachfeld
|
|
for( int j=1; j <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); j++) {
|
|
if( originalDoc.field[Const.gDDF_WEITAUFTRAGSNR][j] != null && !originalDoc.field[Const.gDDF_WEITAUFTRAGSNR][j].equals("") ) {
|
|
newDoc.field[Const.gDDF_WEITAUFTRAGSNR][j] = originalDoc.field[Const.gDDF_WEITAUFTRAGSNR][j]
|
|
}
|
|
if( originalDoc.field[Const.gDDF_ERGDOCFUER][j] != null && !originalDoc.field[Const.gDDF_ERGDOCFUER][j].equals("") ) {
|
|
newDoc.field[Const.gDDF_ERGDOCFUER][j] = originalDoc.field[Const.gDDF_ERGDOCFUER][j]
|
|
}
|
|
}
|
|
|
|
try {
|
|
// neues Dokument importieren
|
|
newDoc = d3.archive.importDocument(newDoc, importFile);
|
|
d3.log.info( "Das Dokument ${lDocIDResultDoc[i]} konnte erfolgreich gecloned werden!" )
|
|
|
|
// Workaround: temporäre Datei für FileExtension wieder entfernen
|
|
boolean documentTempDeleted = deleteClonedDocumentTemp(d3, copiedFileDest)
|
|
if(documentTempDeleted == false) {
|
|
d3.log.error("Temporäres Dokument ${copiedFileDest} konnte nicht gelöscht werden!")
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("Das Dokument ${lDocIDResultDoc[i]} konnte nicht erfolgreich kopiert werden!")
|
|
return
|
|
}
|
|
} else {
|
|
d3.log.error("Das Dokument ${lDocIDResultDoc[i]} konnte nicht erfolgreich kopiert werden!")
|
|
}
|
|
} else {
|
|
d3.log.error("Das Dokument ${lDocIDResultDoc[i]} konnte nicht erfolgreich kopiert werden!")
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Erstellung einer Dublette für Kundenkontaktdokumente
|
|
* @author
|
|
* @see InsertExit, UpdateAttributExit, NewVersionExit
|
|
* @return keine Rückgabe; im Hintergrund werden Dokumente erstellt
|
|
*/
|
|
public static void copyCustAction( D3Interface d3, Document doc, def lMapCustAction ) {
|
|
d3.log.info("Start Functions copyCustAction");
|
|
|
|
// Lösung durch Workaround, Datei wird temporär Zwischengespeichert -> die Filextension verloren geht durch Import von newDocument
|
|
|
|
doc = d3.archive.getDocument(doc.id());
|
|
|
|
def lReturn
|
|
def lContactID
|
|
def lContactDate
|
|
def lContactName
|
|
String lMapNew
|
|
def lDokNeu
|
|
|
|
String[] splittedString = lMapCustAction.split("\\|")
|
|
|
|
if ( splittedString.size() > 0 ) {
|
|
|
|
lContactID = splittedString[0].trim()
|
|
lContactDate = splittedString[1].trim()
|
|
lContactName = splittedString[2].trim()
|
|
|
|
// Ermittlung Filepath im Dokbaum - daher vorher Prüfung notwendig ob Dokument sich auf dem Storage befindet
|
|
def filepath
|
|
def sqlStatement = "SELECT fd.lokalisation as lokalisation FROM files_datentraeger as fd WHERE fd.doku_id NOT LIKE '\$%' AND doku_id = '${doc.id()}'"
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
def originalDocLocalisation = sqlResult.getAt(0).get("lokalisation")
|
|
if( originalDocLocalisation == 2 ) {
|
|
// Dokument befindet sich auf dem Storage und muss vor Ermittlung "zurückgeholt" werden
|
|
// bei Optima kein Storage im Einsatz, daher keine Relevanz
|
|
} else {
|
|
filepath = d3.call.document_get_file_path( doc.id(), "Ar", doc.getFileIdCurrentVersion(), "d3groovy", "")
|
|
}
|
|
|
|
// nur wenn filepath nicht leer ist, kann das Dokument kopiert werden
|
|
if(filepath != null && !filepath.equals("")) {
|
|
|
|
// Workaround: Datei temporär lokal verarbeiten aufgrund der FileExtension
|
|
File fileTemp = new File(filepath)
|
|
def docName = doc.getFilename()
|
|
// Sonderzeichen entfernen
|
|
docName = docName.replaceAll("[\\\\/:*?\"<>|]", "_");
|
|
def docExt = doc.getFileExtension()
|
|
String copiedFileDest = copyDocumentUsingChannel(d3, fileTemp, docName, docExt)
|
|
|
|
if(copiedFileDest != null && !copiedFileDest.equals("") ) {
|
|
|
|
// Neues Dokument definieren
|
|
Path importFile = Paths.get(copiedFileDest);
|
|
|
|
// Eigenschaften im neuen Dokument setzen
|
|
Document newDoc = d3.archive.newDocument();
|
|
newDoc.type = Const.gDTS_DKUKO
|
|
newDoc.status = Document.DocStatus.DOC_STAT_ARCHIVE
|
|
newDoc.setText(3, doc.id())
|
|
newDoc.setText(4, "cloned")
|
|
newDoc.field[Const.gDDF_KONTAKTNUMMER] = lContactID
|
|
SimpleDateFormat dateFormat = new SimpleDateFormat("dd.MM.yyyy");
|
|
Date parsedDate = dateFormat.parse(lContactDate.trim());
|
|
newDoc.field[Const.gDDF_KONTAKTDATE] = parsedDate
|
|
newDoc.field[Const.gDDF_BESCHREIBUNG] = lContactName
|
|
newDoc.field[Const.gDDF_KNR] = doc.field[Const.gDDF_KNR]
|
|
newDoc.field[Const.gDDF_DOKGROUP] = doc.field[Const.gDDF_DOKGROUP]
|
|
newDoc.field[Const.gDDF_AUFTRNR] = doc.field[Const.gDDF_AUFTRNR]
|
|
newDoc.field[Const.gDDF_DOKTITLE] = doc.field[Const.gDDF_DOKTITLE]
|
|
newDoc.field[Const.gDDF_ERDATE] = doc.field[Const.gDDF_ERDATE]
|
|
|
|
try {
|
|
// neues Dokument importieren
|
|
newDoc = d3.archive.importDocument(newDoc, importFile);
|
|
lDokNeu = newDoc.id()
|
|
|
|
// Workaround: temporäre Datei für FileExtension wieder entfernen
|
|
boolean documentTempDeleted = deleteClonedDocumentTemp(d3, copiedFileDest)
|
|
if(documentTempDeleted == false) {
|
|
d3.log.error("Temporäres Dokument ${copiedFileDest} konnte nicht gelöscht werden!")
|
|
}
|
|
|
|
d3.log.info("Das Dokument ${doc.id()} wurde erfolgreich kopiert. Die neue Doku-ID lautet ${lDokNeu}")
|
|
|
|
lMapNew = "bereits zugeordnet " + lMapCustAction
|
|
|
|
doc.field[Const.gDDF_MAPPCUSTACTION] = lMapNew
|
|
try {
|
|
doc.updateAttributes("d3groovy", true);
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error( "Die Aktualisierung des Attributs Zuordnung Kundenkontakt für das Dokument ${doc.id} konnte nicht vorgenommen werden!")
|
|
}
|
|
|
|
} catch(Exception e) {
|
|
d3.log.error("Das Dokument ${doc.id} konnte nicht erfolgreich kopiert werden!")
|
|
return
|
|
}
|
|
} else {
|
|
d3.log.error("Das Dokument ${doc.id} konnte nicht erfolgreich kopiert werden!")
|
|
}
|
|
} else {
|
|
d3.log.error("Das Dokument ${doc.id} konnte nicht erfolgreich kopiert werden!")
|
|
}
|
|
d3.log.info("#### Funktion CopyCustAction wurde beendet ####")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Kopie der übergebenen Datei (mit Hilfe von Channeln)
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return Pfad zur erstellten Datei
|
|
*/
|
|
public static String copyDocumentUsingChannel(D3Interface d3, File source, String fileName, String extension) {
|
|
d3.log.info("Start Functions copyDocumentUsingChannel");
|
|
|
|
String newPath = SystemSpecificConst.cloneDocumentTempPath
|
|
File dest = new File(newPath + "\\\\" + fileName + "." + extension);
|
|
FileChannel sourceChannel = null;
|
|
FileChannel destChannel = null;
|
|
try {
|
|
sourceChannel = new FileInputStream(source).getChannel();
|
|
destChannel = new FileOutputStream(dest).getChannel();
|
|
destChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
|
|
} catch(Exception e) {
|
|
// d3.log.error("copyFileUsingChannel Function Error: Temp Document could not be executed - " + e.getMessage());
|
|
} finally {
|
|
if( sourceChannel != null) {
|
|
sourceChannel.close();
|
|
}
|
|
if( destChannel != null) {
|
|
destChannel.close();
|
|
}
|
|
}
|
|
return dest.getPath();
|
|
}
|
|
|
|
/**
|
|
* Kopie der übergebenen Datei (mit Hilfe von Stream)
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return keine Rückgabe, im Hintergrund wird eine Datei erstellt
|
|
*/
|
|
public static void copyFileUsingStream(File source, File dest) throws IOException {
|
|
InputStream is = null;
|
|
OutputStream os = null;
|
|
try {
|
|
is = new FileInputStream(source);
|
|
os = new FileOutputStream(dest);
|
|
byte[] buffer = new byte[1024];
|
|
int length;
|
|
while ((length = is.read(buffer)) > 0) {
|
|
os.write(buffer, 0, length);
|
|
}
|
|
} catch(Exception e) {
|
|
System.out.println("copyFileUsingStream - " + e.getMessage());
|
|
} finally {
|
|
if( is != null ) {
|
|
is.close();
|
|
}
|
|
if( os != null ) {
|
|
os.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Wenn "neues Angebot" auf "Ja, mit Dokumenten" gesetzt worden ist, kopiere alle Ergebnisdokumente in die neue Angebotsakte
|
|
* @author
|
|
* @see UpdateAttributExit
|
|
* @return keine Rückgabe, im Hintergrund wird ein Dokument kopriert
|
|
*/
|
|
public static void copyOfferDocuments( D3Interface d3, Document doc, def docIdAnNeu ) {
|
|
d3.log.info("Start Functions copyOfferDocuments");
|
|
|
|
def lReturn
|
|
def lResultDok
|
|
def lAnNrNeu
|
|
def lDokNeu
|
|
int lDokCount = 0;
|
|
def lARCDocID
|
|
def lOpportunityNoTMP
|
|
def lBlockSign
|
|
|
|
d3.log.info("Start copyOfferDocuments: Alte Angebotsversion ${doc.id()} - Neue Angebotsversion ${docIdAnNeu}");
|
|
lOpportunityNoTMP = doc.field[Const.gDDF_OPPANNr]
|
|
|
|
//Hole die Doku-ID aller Dokumente aus der Angebotsakte
|
|
|
|
// String[] children = d3.call.link_get_children(doc.id(), "d3groovy") -> wenn das Dokument nicht mehr verknüpft war, dann liefert diese Funktion keine Ergebnisse
|
|
String sqlStatementChildren = "SELECT doku_id as dokId " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_DOPPD}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = ? " +
|
|
"AND dok_dat_feld_${Const.gDDF_OPPANNr} = ? " +
|
|
"AND dok_dat_feld_${Const.gDDF_ERGEBNISDOK} = ? ";
|
|
List<Object> params = [
|
|
doc.field[Const.gDDF_OPPNUMMER],
|
|
doc.field[Const.gDDF_OPPANNr],
|
|
"Ja"
|
|
];
|
|
List<GroovyRowResult> children = d3.sql.executeAndGet(sqlStatementChildren, params);
|
|
if(children != null) {
|
|
lDokCount = children.size();
|
|
}
|
|
|
|
d3.log.info("copyOfferDocuments lDokCount: ${lDokCount}");
|
|
|
|
if( lDokCount > 0 ) {
|
|
|
|
//Schaue, ob das Dokument ein Ergebnisdokument ist
|
|
//Soll nicht fuer Angebote gelten
|
|
for(GroovyRowResult grrChild : children) {
|
|
|
|
try {
|
|
def sqlStatement = "SELECT fs.dok_dat_feld_${Const.gDDF_ERGEBNISDOK} as lResultDok, fs.dok_dat_feld_${Const.gDDF_ARCDOCID} as lARCDocID, pd.frei_o_gesperrt as lBlockSign " +
|
|
"FROM firmen_spezifisch fs, phys_datei pd " +
|
|
"WHERE fs.doku_id = '${grrChild.get("dokId")}' " +
|
|
"AND pd.doku_id = fs.doku_id "
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
lResultDok = sqlResult.getAt(0).get("lResultDok")
|
|
lARCDocID = sqlResult.getAt(0).get("lARCDocID")
|
|
lBlockSign = sqlResult.getAt(0).get("lBlockSign")
|
|
|
|
//Wenn ja, kopiere das Dokument...
|
|
//phoer 20190220: Umgestellt von Prüfung auf Freigabe, denn bei Dokumenten, die nur in Bearbeitung sind, ist lBlockSign = NULL
|
|
if( lResultDok.equals("Ja") && lARCDocID == null && ( !lBlockSign.equals('g') || lBlockSign == null ) ) {
|
|
|
|
//Hole die neue Angebotsnummer
|
|
def sqlStatementSec = "SELECT dok_dat_feld_${Const.gDDF_PROJTITLE} as lAnNrNeu " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE doku_id = '${docIdAnNeu}' "
|
|
|
|
List<GroovyRowResult> sqlResultSec = d3.getSql().executeAndGet(sqlStatementSec)
|
|
lAnNrNeu = sqlResultSec.getAt(0).get("lAnNrNeu")
|
|
|
|
// Eigenschaften des Original Dokumentes laden
|
|
Document originalDoc = d3.archive.getDocument(grrChild.get("dokId"));
|
|
|
|
// Ermittlung Filepath im Dokbaum
|
|
Map<String, String> statusMap = new HashMap<String, String>();
|
|
statusMap.put("DOC_STAT_VERIFICATION", "Pr");
|
|
statusMap.put("DOC_STAT_RELEASE", "Fr");
|
|
statusMap.put("DOC_STAT_PROCESSING", "Be");
|
|
statusMap.put("DOC_STAT_ARCHIVE", "Ar");
|
|
|
|
def filepath = d3.call.document_get_file_path( grrChild.get("dokId"), statusMap.get(originalDoc.getStatus().toString()), originalDoc.getFileIdCurrentVersion(), "d3groovy", "");
|
|
|
|
d3.log.info("copyOfferDocuments filepath : ${filepath}");
|
|
|
|
// nur wenn filepath nicht leer ist, kann das Dokument kopiert werden
|
|
if(filepath != null && !filepath.equals("")) {
|
|
|
|
// Workaround: Datei temporär lokal verarbeiten aufgrund der FileExtension
|
|
File fileTemp = new File(filepath)
|
|
def docName = originalDoc.getFilename()
|
|
// Sonderzeichen entfernen
|
|
docName = docName.replaceAll("[\\\\/:*?\"<>|]", "_");
|
|
def docExt = originalDoc.getFileExtension()
|
|
String copiedFileDest = copyDocumentUsingChannel(d3, fileTemp, docName, docExt)
|
|
|
|
if(copiedFileDest != null && !copiedFileDest.equals("") ) {
|
|
|
|
// Neues Dokument definieren
|
|
Path importFile = Paths.get(copiedFileDest);
|
|
|
|
// Eigenschaften im neuen Dokument setzen
|
|
Document newDoc = d3.archive.newDocument();
|
|
newDoc.type = Const.gDTS_DOPPD
|
|
|
|
// notwendig bis Server Hotfix 36
|
|
// newDoc.status = Document.DocStatus.DOC_STAT_RELEASE
|
|
|
|
newDoc.status = Document.DocStatus.DOC_STAT_PROCESSING
|
|
// 30.03.2023 Quicktag.dxp Anpassung bzw. Server Update Annual (Anpassung der Gruppe auf technischen Kürzel notwendig)
|
|
//newDoc.editor = "d3_grp_all";
|
|
newDoc.editor = "d3_grp_a";
|
|
newDoc.setText(3, originalDoc.id())
|
|
newDoc.setText(4, "cloned")
|
|
|
|
newDoc.field[Const.gDDF_OPPANNr] = lAnNrNeu
|
|
newDoc.field[Const.gDDF_ADITTITLE] = ""
|
|
|
|
// alle Pflichtfelder und Erkennungsattribute müssen geholt werden inklusive Buchungskreis!
|
|
newDoc.field[Const.gDDF_OPPNUMMER] = doc.field[Const.gDDF_OPPNUMMER]
|
|
newDoc.field[Const.gDDF_ERDATE] = originalDoc.field[Const.gDDF_ERDATE]
|
|
newDoc.field[Const.gDDF_DOKTITLE] = originalDoc.field[Const.gDDF_DOKTITLE]
|
|
newDoc.field[Const.gDDF_DOKGROUP] = originalDoc.field[Const.gDDF_DOKGROUP]
|
|
newDoc.field[Const.gDDF_ANNAME] = doc.field[Const.gDDF_ANNAME]
|
|
newDoc.field[Const.gDDF_BUCHKREIS] = doc.field[Const.gDDF_BUCHKREIS]
|
|
// kopiertes Dokument soll den Status Ergebnisdokuemnt ja behalten
|
|
newDoc.field[Const.gDDF_ERGEBNISDOK] = "Ja";
|
|
|
|
try {
|
|
// neues Dokument importieren
|
|
newDoc = d3.archive.importDocument(newDoc, importFile);
|
|
lDokNeu = newDoc.id()
|
|
|
|
// d3.log.error( "Vor dem Link: :(lOpportunityNoTMP) = :(dok_dat_feld[gDDF_OPPANNr])" )
|
|
//...und verknüpfe es mit dem neuen Dokument
|
|
// Dokument zu Dokument Verknüpfung
|
|
lReturn = d3.call.link_documents( lDokNeu, grrChild.get("dokId"), "d3groovy", false, false )
|
|
// Akte zu Dokument Verknüpfung -> erfolgt durch Aktenplan:
|
|
// lReturn2 = d3.call.link_documents(docIdAnNeu, lDokNeu, "d3groovy", false, false)
|
|
|
|
// Workaround: temporäre Datei für FileExtension wieder entfernen
|
|
boolean documentTempDeleted = deleteClonedDocumentTemp(d3, copiedFileDest)
|
|
if(documentTempDeleted == false) {
|
|
d3.log.error("Temporäres Dokument ${copiedFileDest} konnte nicht gelöscht werden!")
|
|
}
|
|
|
|
// Workaround: Nach dem link_documents hat er in der Variablen dok_dat_feld[gDDF_OPPANNr] die Angebot_Nr der gerade angelegten Akte stehen.
|
|
// Das führt in der Folge zu Fehlern, dass Dokumente der gerade geclonten Akte mit der falschen "neuen" Angebotsnummer bestückt werden.
|
|
// call api_log_error( "Test wegen Ticket: NACH dem link_dokuments dok_dat_feld[gDDF_OPPANNr]: :(dok_dat_feld[gDDF_OPPANNr])" )
|
|
// dok_dat_feld[gDDF_OPPANNr] = lOpportunityNoTMP
|
|
// call api_log_error( "Nach dem dem Link: :(lOpportunityNoTMP) = :(dok_dat_feld[gDDF_OPPANNr])" )
|
|
|
|
if( lReturn == 0) {
|
|
d3.log.info("Das Angebotsdokument ${grrChild.get("dokId")} wurde erfolgreich mit dem neuen Dokument verknüpft!")
|
|
} else {
|
|
d3.log.error("Das Angebotsdokument ${grrChild.get("dokId")} wurde nicht erfolgreich mit mit dem neuen Dokument verknüpft!")
|
|
}
|
|
|
|
} catch(Exception e) {
|
|
d3.log.error("copyOfferDocuments error = " + e.getMessage())
|
|
d3.log.error("Das Dokument " + grrChild.get("dokId") + " konnte nicht erfolgreich kopiert werden!")
|
|
}
|
|
} else {
|
|
d3.log.error("Das Dokument ${doc.id()} konnte nicht erfolgreich kopiert werden!")
|
|
}
|
|
} else {
|
|
d3.log.error("Das Dokument ${doc.id()} konnte nicht erfolgreich kopiert werden!")
|
|
}
|
|
}
|
|
} catch(Exception e2) {
|
|
d3.log.error("copyOfferDocuments error = " + e2.getMessage());
|
|
d3.log.error("Das Dokument " + grrChild.get("dokId") + " konnte nicht erfolgreich kopiert werden!")
|
|
}
|
|
}
|
|
} else {
|
|
d3.log.error("Die Angebotsrelevanten Dokumente konnten nicht gefunden werden!")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Übernahme aller Ergebnisdokumente aus der Opportunity in Maschinenprojektakte (Übergabe/Aufträge)
|
|
* Die Dokumente werden in die Auftragsakte verlinkt (bisherige Funktion)
|
|
* Außerdem sollen die Dokumente in die Akte Ergebnis Opportunity festgeschrieben werden
|
|
* @author
|
|
* @see InsertExit, UpdateAttributExit
|
|
* @return keine Rückgabe, im Hintergrund wird ein Dokument kopiert
|
|
*/
|
|
public static void copyResultDocs(D3Interface d3, Document doc, def lBaseOpp, def lOrderNo) {
|
|
d3.log.info("Start Functions copyResultDocs = " + doc.id());
|
|
|
|
//prüfe, ob bereits eine Auftragsakte generiert wurde...
|
|
def lOrderDocID
|
|
def lOrderCount
|
|
def lResultRecordDocID
|
|
def lResultCount
|
|
def lBaseOfferCount
|
|
def retval
|
|
def l60Count
|
|
def tmp_orderNo
|
|
def tmp_CustNo
|
|
def tmp_CustName
|
|
def tmp_Process
|
|
def tmp_BU
|
|
def tmp_MainOrd
|
|
|
|
def sqlStatementOrderDoc = "SELECT doku_id as lOrderDocID " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AMAUF}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lOrderNo}' ";
|
|
List<GroovyRowResult> sqlResultOrderDoc = d3.getSql().executeAndGet(sqlStatementOrderDoc);
|
|
if(sqlResultOrderDoc != null && sqlResultOrderDoc.size()> 0) {
|
|
lOrderCount = sqlResultOrderDoc.size();
|
|
lOrderDocID = sqlResultOrderDoc.getAt(0).get("lOrderDocID");
|
|
}
|
|
|
|
def sqlStatementRecordDoc = "SELECT doku_id as lResultRecordDocID " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AMEOP}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lOrderNo}' ";
|
|
List<GroovyRowResult> sqlResultRecordDoc = d3.getSql().executeAndGet(sqlStatementRecordDoc);
|
|
if(sqlResultRecordDoc != null && sqlResultRecordDoc.size()> 0) {
|
|
lResultCount = sqlResultRecordDoc.size();
|
|
lResultRecordDocID = sqlResultRecordDoc.getAt(0).get("lResultRecordDocID");
|
|
}
|
|
|
|
// Wenn die Ergebnis Opportunity Akte noch nicht existiert
|
|
if( lResultCount != null && lResultCount == 0 ) {
|
|
|
|
//...erstelle die Ergebnis Opportunity Akte (Achtung: Nur für den Prototyp, Akte wird vermutlich durch SAP erstellt)
|
|
tmp_orderNo = doc.field[Const.gDDF_AUFTRNR]
|
|
tmp_CustNo = doc.field[Const.gDDF_KNR]
|
|
tmp_CustName = doc.field[Const.gDDF_KNAME]
|
|
tmp_Process = doc.field[Const.gDDF_PROZESS]
|
|
tmp_BU = doc.field[Const.gDDF_BUCHKREIS]
|
|
tmp_MainOrd = doc.field[Const.gDDF_PROJKLAMMER]
|
|
|
|
Document newFolder = d3.Archive.newDocument()
|
|
newFolder.type = Const.gDTS_AMEOP
|
|
newFolder.status = Document.DocStatus.DOC_STAT_RELEASE
|
|
newFolder.field[Const.gDDF_AUFTRNR] = tmp_orderNo
|
|
newFolder.field[Const.gDDF_KNR] = tmp_CustNo
|
|
newFolder.field[Const.gDDF_KNAME] = tmp_CustName
|
|
newFolder.field[Const.gDDF_PROZESS] = tmp_Process
|
|
newFolder.field[Const.gDDF_BUCHKREIS] = tmp_BU
|
|
newFolder.field[Const.gDDF_PROJKLAMMER] = tmp_MainOrd
|
|
newFolder.field[Const.gDDF_SUBJECT] = Const.gAK_ErgebnisOpportuntiy
|
|
|
|
retval = d3.call.folder_create(newFolder) //Verknüpfung dieser Akte erfolgt im Standard Aktenplan
|
|
if( retval == 0 ) {
|
|
lResultCount = 1
|
|
}
|
|
}
|
|
|
|
if( lResultCount == 1 ) {
|
|
|
|
// Kopiere die Ergebnisdokumente in die Akte "Ergebnis Opportunity"
|
|
//...suche dir alle Dokumente mit Ergebnis-Charakter aus der zugrundeliegenden Opportuntity...
|
|
def sqlStatement = "SELECT f.doku_id as lResOppDocID, f.dok_dat_feld_${Const.gDDF_OPPNUMMER} as lOppNr " +
|
|
"FROM firmen_spezifisch as f, dokuart_langtexte as d, phys_datei as pd " +
|
|
"WHERE f.dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lBaseOpp}' " +
|
|
"AND f.dok_dat_feld_${Const.gDDF_ERGEBNISDOK} = 'Ja' " +
|
|
"AND f.kue_dokuart <> '${Const.gDTS_DMEOP}' " +
|
|
"AND d.sprache = '049' " +
|
|
"AND d.kue_dokuart = f.kue_dokuart " +
|
|
"AND ( pd.frei_o_gesperrt = 'f' " +
|
|
"OR pd.frei_o_gesperrt IS NULL ) " +
|
|
"AND pd.doku_id = f.doku_id "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.getSql().executeAndGet(sqlStatement)
|
|
|
|
if( sqlResult != null && sqlResult.size() > 0 ) {
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
|
|
try {
|
|
// Eigenschaften des Original Dokumentes laden
|
|
Document originalDoc = d3.archive.getDocument(grr.get("lResOppDocID"));
|
|
|
|
// Ermittlung Filepath im Dokbaum
|
|
Map<String, String> statusMap = new HashMap<String, String>();
|
|
statusMap.put("DOC_STAT_VERIFICATION", "Pr");
|
|
statusMap.put("DOC_STAT_RELEASE", "Fr");
|
|
statusMap.put("DOC_STAT_PROCESSING", "Be");
|
|
statusMap.put("DOC_STAT_ARCHIVE", "Ar");
|
|
String filepath = d3.call.document_get_file_path( originalDoc.id(), statusMap.get(originalDoc.getStatus().toString()), originalDoc.getFileIdCurrentVersion(), "d3groovy", "");
|
|
|
|
// nur wenn filepath nicht leer ist, kann das Dokument kopiert werden
|
|
if(filepath != null && !filepath.equals("")) {
|
|
|
|
// Workaround: Datei temporär lokal verarbeiten aufgrund der FileExtension
|
|
def docName = originalDoc.getFilename()
|
|
// Sonderzeichen entfernen
|
|
docName = docName.replaceAll("[\\\\/:*?\"<>|]", "_");
|
|
def docExt = originalDoc.getFileExtension()
|
|
Path sourceFile = Paths.get(filepath);
|
|
|
|
Date dateLog = new Date();
|
|
SimpleDateFormat sdfLog = new SimpleDateFormat("yyyyMMddHHmmssSSS");
|
|
String dateString = sdfLog.format(dateLog);
|
|
|
|
Path targetFile = Paths.get("F:\\d3\\Hostimport\\CopyDMEOP\\" + docName + "_" + dateString + "." + docExt);
|
|
try {
|
|
Files.copy(sourceFile, targetFile, StandardCopyOption.REPLACE_EXISTING);
|
|
} catch(Exception e) {
|
|
d3.log.error("copyResultDocs error = " + e);
|
|
}
|
|
File newFile = new File(targetFile.toString());
|
|
|
|
if(newFile.exists()) {
|
|
|
|
Document copyDoc = d3.archive.newDocument();
|
|
copyDoc.setType(Const.gDTS_DMEOP);
|
|
|
|
// Kopie aller Ergebnisdokumente in die Dokumentart Ergebnisdokumente Opportunity (in Maschinenprojekt)
|
|
File lPathJPL = new File("F:\\d3\\Hostimport\\CopyDMEOP\\" + docName + "_" + dateString + "." + "jpl")
|
|
lPathJPL.append("logi_verzeichnis = \"Ar\"" + System.lineSeparator())
|
|
lPathJPL.append("dokuart = \"${Const.gDTS_DMEOP}\"" + System.lineSeparator())
|
|
lPathJPL.append("text[3] = \"${originalDoc.id()}\"" + System.lineSeparator())
|
|
lPathJPL.append("text[4] = \"Ergebnisdokument cloned\"" + System.lineSeparator())
|
|
|
|
// Pflichtattribute
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_DOKTITLE}] = \"" + checkValueForJpl(originalDoc.field[Const.gDDF_DOKTITLE]) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_AUFTRNR}] = \"" + checkValueForJpl(lOrderNo) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_DOKGROUP}] = \"" + checkValueForJpl(originalDoc.field[Const.gDDF_DOKGROUP]) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_OPPNUMMER}] = \"" + checkValueForJpl(lBaseOpp) + "\"" + System.lineSeparator())
|
|
lPathJPL.append( "dok_dat_feld[${Const.gDDF_ERDATE}] = \"" + originalDoc.field[Const.gDDF_ERDATE] + "\"" + System.lineSeparator())
|
|
//lPathJPL.append( "dok_dat_feld[${Const.gDDF_STATUS}] = \"" + originalDoc.field[Const.gDDF_STATUS] + "\"" + System.lineSeparator())
|
|
|
|
// Zusatzfelder
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gProzessGroupId, Const.gDDF_PROZESSGROUP, checkValueForJpl(originalDoc.field[Const.gDDF_PROZESSGROUP]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gRepIDProzessart, Const.gDDF_PROZESSART, checkValueForJpl(originalDoc.field[Const.gDDF_PROZESSART]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gAbtsenderID, Const.gDDF_ABTSENDER, checkValueForJpl(originalDoc.field[Const.gDDF_ABTSENDER]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gSenderID, Const.gDDF_SENDER, checkValueForJpl(originalDoc.field[Const.gDDF_SENDER]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gLieferantNrID, Const.gDDF_LNR, checkValueForJpl(originalDoc.field[Const.gDDF_LNR]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gLieferantNaID, Const.gDDF_LNAME, checkValueForJpl(originalDoc.field[Const.gDDF_LNAME]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gKundenkontaktIDID, Const.gDDF_KONTAKTNUMMER, checkValueForJpl(originalDoc.field[Const.gDDF_KONTAKTNUMMER]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gAdittitleID, Const.gDDF_ADITTITLE, checkValueForJpl(originalDoc.field[Const.gDDF_ADITTITLE]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gKundennrID, Const.gDDF_KNR, checkValueForJpl(originalDoc.field[Const.gDDF_KNR]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gKundennameID, Const.gDDF_KNAME, checkValueForJpl(originalDoc.field[Const.gDDF_KNAME]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gBuchungskreisID, Const.gDDF_BUCHKREIS, checkValueForJpl(originalDoc.field[Const.gDDF_BUCHKREIS]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gOpportunityNrID, Const.gDDF_OPPNUMMER, checkValueForJpl(originalDoc.field[Const.gDDF_OPPNUMMER]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gKommunikationsrichtID, Const.gDDF_KOMMRICHTUNG, checkValueForJpl(originalDoc.field[Const.gDDF_KOMMRICHTUNG]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gJahrID, Const.gDDF_JAHR, checkValueForJpl(originalDoc.field[Const.gDDF_JAHR]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gMonatID, Const.gDDF_MONAT, checkValueForJpl(originalDoc.field[Const.gDDF_MONAT]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gVerkaufsphaseID, Const.gDDF_VKPHASE, checkValueForJpl(originalDoc.field[Const.gDDF_VKPHASE]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gHauptOpportunityID, Const.gDDF_HAUPTOPP, checkValueForJpl(originalDoc.field[Const.gDDF_HAUPTOPP]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gSubmissionID, Const.gDDF_SUBMISSION, checkValueForJpl(originalDoc.field[Const.gDDF_SUBMISSION]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gAbteilungOrgID, Const.gDFF_ABTEILUNG, checkValueForJpl(originalDoc.field[Const.gDFF_ABTEILUNG]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gAngebotsnameID, Const.gDDF_ANNAME, checkValueForJpl(originalDoc.field[Const.gDDF_ANNAME]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gErgebnisDokID, Const.gDDF_ERGEBNISDOK, checkValueForJpl(originalDoc.field[Const.gDDF_ERGEBNISDOK]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gKundenkontaktKategorieID, Const.gDDF_KDAKTKAT, checkValueForJpl(originalDoc.field[Const.gDDF_KDAKTKAT]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gSalesgroupID, Const.gDDF_SALESGROUP, checkValueForJpl(originalDoc.field[Const.gDDF_SALESGROUP]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gArcdocidID, Const.gDDF_ARCDOCID, checkValueForJpl(originalDoc.field[Const.gDDF_ARCDOCID]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gDokgroupID, Const.gDDF_DOKGRP, checkValueForJpl(originalDoc.field[Const.gDDF_DOKGRP]));
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gOppannrID, Const.gDDF_OPPANNr, checkValueForJpl(originalDoc.field[Const.gDDF_OPPANNr]));
|
|
|
|
String originalDocType = originalDoc.getType().id();
|
|
if( originalDocType != null ) {
|
|
if( originalDocType.equals(Const.gDTS_DKOMM) ) {
|
|
appendJplIfAttribExists(d3, doc, copyDoc.getType(), lPathJPL, SystemSpecificConst.gDokgroupID, Const.gDDF_DOKGROUP, Const.gDG_Kommunikation);
|
|
}
|
|
}
|
|
|
|
// Stichinformation für den hostimport - daher als letztes importieren
|
|
File lPathAction = new File("F:\\d3\\Hostimport\\CopyDMEOP\\" + docName + "_" + dateString + "." + "action")
|
|
lPathAction.append("import_file_ext = \"" + docExt + "\"" + System.lineSeparator())
|
|
|
|
} else {
|
|
d3.log.error("Das Dokument ${doc.id()} konnte nicht erfolgreich kopiert werden!")
|
|
}
|
|
} else {
|
|
d3.log.error("Das Dokument ${doc.id()} konnte nicht erfolgreich kopiert werden!")
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("Error Functions copyResultDocs " + doc.id() + " = " + e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
d3.log.info("copyResultDocs beendet");
|
|
}
|
|
|
|
/**
|
|
* Hilfemethode um die Anzahl der gefüllten Mehrfachfelder zu ermmitteln
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return Anzahl gefüllter Mehrfachfelder
|
|
*/
|
|
public static int countArrayElements(D3Interface d3, Document doc, int field) {
|
|
d3.log.info("Start Functions countArrayElements");
|
|
|
|
int counter = 0;
|
|
for(int i=1; i<=Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if(doc.field[field][i] != null) {
|
|
counter = counter + 1;
|
|
}
|
|
}
|
|
return counter;
|
|
}
|
|
|
|
/**
|
|
* Löscht eine temporäre Datei zum koprieren von Dokumenten
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return true=erfolgreich gelöscht; false=nicht gelöscht
|
|
*/
|
|
public static boolean deleteClonedDocumentTemp(D3Interface d3, String fileDestination) {
|
|
d3.log.info("Start Functions deleteClonedDocumentTemp");
|
|
|
|
File dest = new File(fileDestination)
|
|
try {
|
|
dest.delete()
|
|
return true
|
|
} catch(Exception e) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hinzuvalidierung aller notwendigen Werte für Hauptvorgangsakte
|
|
* @author Unterstützende Prozesse
|
|
* @see InsertEntry, UpdateAttribEntry
|
|
*/
|
|
public static void entryFunctionMainfolder(D3Interface d3, Document doc, User pUser, int pX) {
|
|
d3.log.info("Start Functions entryFunctionMainfolder");
|
|
|
|
def lNum
|
|
def lRetVal
|
|
|
|
if( doc.field[Const.gDDF_VOROWNER].equals("") || doc.field[Const.gDDF_VOROWNER] == null) {
|
|
doc.field[Const.gDDF_VOROWNER] = pUser.id
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_VORGANGSSTATUS].equals("") || doc.field[Const.gDDF_VORGANGSSTATUS] == null) {
|
|
doc.field[Const.gDDF_VORGANGSSTATUS] = "offen"
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_BUCHKREIS68][1].equals("") || doc.field[Const.gDDF_BUCHKREIS68][1] == null ) {
|
|
doc.field[Const.gDDF_BUCHKREIS68][1] = pUser.getOptField(2)
|
|
}
|
|
|
|
if( (doc.field[Const.gDDF_ORDNUNG].equals("") || doc.field[Const.gDDF_ORDNUNG] == null) || pX == 1 ) {
|
|
def sqlStatement = "SELECT * FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_AHAUP}' and dok_dat_feld_${Const.gDDF_PROZESS} = '${doc.field[Const.gDDF_PROZESS]}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
lNum = sqlResult.size()
|
|
lNum = lNum + 1
|
|
String comlNum = fillNullValues(lNum, 5);
|
|
doc.field[Const.gDDF_ORDNUNG] = comlNum;
|
|
}
|
|
|
|
if( !doc.field[Const.gDDF_HAUPTVOBEZ].equals("") && doc.field[Const.gDDF_HAUPTVOBEZ] != null ) {
|
|
lRetVal = doc.field[Const.gDDF_HAUPTVOBEZ].indexOf("|")
|
|
if (lRetVal > 0) {
|
|
lRetVal = doc.field[Const.gDDF_HAUPTVOBEZ].replace("|", "I")
|
|
doc.field[Const.gDDF_HAUPTVOBEZ] = lRetVal
|
|
}
|
|
}
|
|
|
|
for(int i=1; i<= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if(doc.field[Const.gDDF_TEILVOBEZGEN][i] != null) {
|
|
lRetVal = doc.field[Const.gDDF_TEILVOBEZGEN][i].indexOf("|")
|
|
if (lRetVal > 0) {
|
|
lRetVal = doc.field[Const.gDDF_TEILVOBEZGEN][i].replace("|", "I")
|
|
doc.field[Const.gDDF_TEILVOBEZGEN][i] = lRetVal
|
|
}
|
|
}
|
|
}
|
|
|
|
if(pX == 1) {
|
|
//Für den Fall, dass AHAUP unter AHAUP angelegt wird
|
|
doc.field[Const.gDDF_VOROWNER] = pUser.id;
|
|
doc.field[Const.gDDF_HAUPTVONR] = "";
|
|
for( int i = 1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
doc.field[Const.gDDF_TEILVONRM][i] = "";
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Neue ECR: Ermittlung ECR Aktivitäts_ID für diese Projekt_Nr ermitteln
|
|
* @author
|
|
* @see InsertEntry
|
|
* @return keine Rückgabe; im Hintergrund wird das Feld Const.gDDF_AKTIVITAETSID gefüllt
|
|
*/
|
|
public static void fillActivityId( D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions fillActivityId");
|
|
|
|
def lUECRNrMax
|
|
def lUECRNr
|
|
|
|
SimpleDateFormat dateFormat = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
|
|
Date date = new Date();
|
|
String todayAsString = dateFormat.format(date);
|
|
|
|
def sqlStatement = "SELECT max(SUBSTRING(dok_dat_feld_${Const.gDDF_AKTIVITAETSID},11,4)) as lUECRNrMax " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_AKTIVITAETSID} like 'Neuer ECR %' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AMECR}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '${doc.field[Const.gDDF_AUFTRNR]}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null && sqlResult.size() > 0) {
|
|
def stringResult = sqlResult.getAt(0).get("lUECRNrMax")
|
|
if(stringResult != null) {
|
|
lUECRNrMax = Integer.valueOf(stringResult.trim())
|
|
}
|
|
}
|
|
|
|
if( lUECRNrMax != null ) {
|
|
lUECRNrMax = lUECRNrMax + 1
|
|
|
|
// call api_function( "string_fill_leading_char", lUECRNrMax, "0", 4 )
|
|
// TODO Prüfung notwendig, ob die führenden Nullen hinzugefügt werden
|
|
lUECRNrMax = String.format ("%04d", lUECRNrMax);
|
|
|
|
lUECRNr = "Neuer ECR " + lUECRNrMax + " " + todayAsString;
|
|
} else {
|
|
lUECRNr = "Neuer ECR 0001 ${todayAsString}"
|
|
}
|
|
|
|
doc.field[Const.gDDF_AKTIVITAETSID] = lUECRNr.toString();
|
|
}
|
|
|
|
/**
|
|
* Hilfsmethode um einen Zahlenwert mit führenden Nullen aufzufüllen
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return String mit führenden Nullen gemäß Definition
|
|
*/
|
|
public static String fillNullValues(int value, int len) {
|
|
String result = String.valueOf(value);
|
|
while (result.length() < len) {
|
|
result = "0" + result;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
public static void inheritAkontAttributes( D3Interface d3, Document doc, Document gOldDoc, User user ) {
|
|
d3.log.info("Start Functions inheritAkontAttributes");
|
|
|
|
// Prüfung der Änderungen an der Akte (ddfValueChanged enhält alle DDF mit ; getrennt)
|
|
String ddfValueChanged = null;
|
|
boolean updateNeeded = false;
|
|
|
|
// Kundenkontakt Kategorie
|
|
boolean kdkontaktkChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_KDAKTKAT);
|
|
if(kdkontaktkChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_KDAKTKAT);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_KDAKTKAT);
|
|
}
|
|
}
|
|
|
|
// Kundenkontakt
|
|
boolean kdkontaktChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_KDAKTNAME);
|
|
if(kdkontaktChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_KDAKTNAME);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_KDAKTNAME);
|
|
}
|
|
}
|
|
|
|
// Kundenkontakt Datum
|
|
boolean kdkontaktdateChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_KONTAKTDATE);
|
|
if(kdkontaktdateChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_KONTAKTDATE);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_KONTAKTDATE);
|
|
}
|
|
}
|
|
|
|
// Kundennummer
|
|
boolean knrChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_KNR);
|
|
if(knrChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_KNR);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_KNR);
|
|
}
|
|
}
|
|
|
|
// Prozess
|
|
boolean processChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_PROZESS);
|
|
if(processChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_PROZESS);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_PROZESS);
|
|
}
|
|
}
|
|
|
|
// Verkäufergruppe
|
|
boolean salesgChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_SALESGROUP);
|
|
if(salesgChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_SALESGROUP);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_SALESGROUP);
|
|
}
|
|
}
|
|
|
|
// Buchungskreis Einfachfeld
|
|
boolean buchungskeChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_BUCHKREIS);
|
|
if(buchungskeChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_BUCHKREIS);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_BUCHKREIS);
|
|
}
|
|
}
|
|
|
|
// Opportunity Nummer
|
|
boolean oppChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_OPPNUMMER);
|
|
if(oppChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_OPPNUMMER);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_OPPNUMMER);
|
|
}
|
|
}
|
|
|
|
// Auftragsnummer / Projektnummer
|
|
boolean auftnrChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_AUFTRNR);
|
|
if(auftnrChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_AUFTRNR);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_AUFTRNR);
|
|
}
|
|
}
|
|
|
|
// Kundenkontakt_ID
|
|
boolean kdkidChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_KONTAKTNUMMER);
|
|
if(kdkidChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_KONTAKTNUMMER);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_KONTAKTNUMMER);
|
|
}
|
|
}
|
|
|
|
// Buchungskreis Mehrfachfeld
|
|
boolean buchungskChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_BUCHKREIS68);
|
|
if(buchungskChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_BUCHKREIS68);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_BUCHKREIS68);
|
|
}
|
|
}
|
|
if(ddfValueChanged != null) {
|
|
updateNeeded = true;
|
|
}
|
|
|
|
if(updateNeeded == true) {
|
|
// Zur Aktualisierung der Dokumente -> Akte markieren für die Verarbeitung im Skript CheckMassDataChanged!
|
|
try {
|
|
// Ermittlung der bisherigen Einträge
|
|
String sqlStatementMdc = "SELECT doc_id FROM mass_data_change WHERE doc_id = '${doc.id()}' "
|
|
List<GroovyRowResult> sqlResultMdc = d3.sql.executeAndGet(sqlStatementMdc);
|
|
int indexCounter = sqlResultMdc.size();
|
|
if(indexCounter == 0) {
|
|
String sqlStatementMdcInsert = "INSERT INTO mass_data_change (doc_id, field_name, field_index, field_value) VALUES ('${doc.id()}', 'MDC-AKONT', 1, '${ddfValueChanged}') ";
|
|
int returnValue = d3.sql.execute(sqlStatementMdcInsert);
|
|
} else if(indexCounter >= 1) {
|
|
indexCounter = indexCounter + 1;
|
|
String sqlStatementMdcInsert = "INSERT INTO mass_data_change (doc_id, field_name, field_index, field_value) VALUES ('${doc.id()}', 'MDC-AKONT', ${indexCounter}, '${ddfValueChanged}') ";
|
|
int returnValue = d3.sql.execute(sqlStatementMdcInsert);
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("Error Functions inheritAkontAttributes - Akte ${doc.id()} konnte nicht in die Tabelle mass_data_change ergänzt werden: " + e);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Vererbung eines neuen Angebotsnamens auf alle darunterliegenden Dokumente und Akten
|
|
* @author
|
|
* @see UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund wird der Angebotsname vererbt
|
|
*/
|
|
public static void inheritANNameNew( D3Interface d3, Document doc, User user ) {
|
|
d3.log.info("Start Functions inheritANNameNew");
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritANNameNew Verarbeitung JPL Asynchron");
|
|
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritANNameNew", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", doc.field[Const.gDDF_ANNAME], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
|
|
|
|
List<String> lChild1 = d3.call.link_get_children(doc.id(), "d3groovy");
|
|
//d3.log.info("Functions inheritANNameNew Verarbeitung Asynchron");
|
|
//Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
//attribUpdate.put(Const.gDDF_ANNAME, doc.field[Const.gDDF_ANNAME]);
|
|
//createAsyncJobForUpdates(d3, doc, lChild1, attribUpdate, "inheritANNameNew");
|
|
|
|
|
|
for( int i = 0; i < lChild1.size(); i++) {
|
|
// Durchlauf aller Angebotsversionen (synchron notwendig, da es sonst Fehler im Async Job der Kinddokumente gab)
|
|
Document docFolder = d3.archive.getDocument(lChild1[i]);
|
|
if(docFolder != null) {
|
|
docFolder.field[Const.gDDF_ANNAME] = doc.field[Const.gDDF_ANNAME];
|
|
try {
|
|
docFolder.updateAttributes(SystemSpecificConst.updatedUser, true);
|
|
} catch(Exception e) {
|
|
d3.log.error("Functions inheritANNameNew - Akte ${lChild1[i]} konnte nicht aktualisiert werden");
|
|
}
|
|
}
|
|
}
|
|
|
|
for( int i = 0; i < lChild1.size(); i++) {
|
|
// Durchlauf für die Angebotsdokumente
|
|
List<String> lChild2 = d3.call.link_get_children(lChild1[i], "d3groovy")
|
|
if(lChild2 != null && lChild2.size() > 0) {
|
|
Map<Integer, Object> attribUpdate2 = new HashMap<>();
|
|
attribUpdate2.put(Const.gDDF_ANNAME, doc.field[Const.gDDF_ANNAME]);
|
|
// Ermittlung der Angebotsnummer, da ansonsten das Update schief läuft
|
|
String sqlStatement = "SELECT f.dok_dat_feld_${Const.gDDF_PROJTITLE} as val " +
|
|
"FROM firmen_spezifisch as f, phys_datei as p " +
|
|
"WHERE f.kue_dokuart = '${Const.gDTS_AREGI}' " +
|
|
"AND p.frei_o_gesperrt = 'f' " +
|
|
"AND p.doku_id = f.doku_id " +
|
|
"AND f.dok_dat_feld_${Const.gDDF_ANNAME} = '${doc.field[Const.gDDF_ANNAME]}' " +
|
|
"AND f.dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${doc.field[Const.gDDF_OPPNUMMER]}' ";
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null && sqlResult.size() == 1) {
|
|
String angebotsNrTemp = sqlResult.getAt(0).get("val");
|
|
if(angebotsNrTemp != null && !angebotsNrTemp.equals("")) {
|
|
attribUpdate2.put(Const.gDDF_OPPANNr, angebotsNrTemp);
|
|
}
|
|
}
|
|
createAsyncJobForUpdates(d3, doc, lChild2, attribUpdate2, "inheritANNameNew");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Veerbung der Eigenschaften für Lieferantenaktivitätsdokumente
|
|
* @author
|
|
* @see UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund werden Eigenschaften vererbt
|
|
*/
|
|
public static int inheritLiefAttrib(D3Interface d3, Document doc, DocumentType docType, String userName, Document docBeforeUpdate) {
|
|
d3.log.info("Start Functions inheritLiefAttrib");
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritLiefAttrib Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritLiefAttrib", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", docBeforeUpdate.field[Const.gDDF_LNR], 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", docBeforeUpdate.field[Const.gDDF_LIEFAKTKAT], 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", docBeforeUpdate.field[Const.gDDF_KONTAKTDATE], 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[5]", docBeforeUpdate.field[Const.gDDF_KONTAKTBESCH], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
|
|
} else {
|
|
d3.log.info("Functions inheritLiefAttrib Verarbeitung Asynchron");
|
|
def sqlStatement = "SELECT doku_id as dokuId " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_DLONT}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_LNR} = '${docBeforeUpdate.field[Const.gDDF_LNR]}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_LIEFAKTKAT} = '${docBeforeUpdate.field[Const.gDDF_LIEFAKTKAT]}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KONTAKTDATE} = '${docBeforeUpdate.field[Const.gDDF_KONTAKTDATE]}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KONTAKTBESCH} = '${docBeforeUpdate.field[Const.gDDF_KONTAKTBESCH]}' ";
|
|
List<GroovyRowResult> result = d3.sql.executeAndGet(sqlStatement);
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_LNR, doc.field[Const.gDDF_LNR]);
|
|
attribUpdate.put(Const.gDDF_LIEFAKTKAT, doc.field[Const.gDDF_LIEFAKTKAT]);
|
|
attribUpdate.put(Const.gDDF_KONTAKTDATE, doc.field[Const.gDDF_KONTAKTDATE]);
|
|
attribUpdate.put(Const.gDDF_KONTAKTBESCH, doc.field[Const.gDDF_KONTAKTBESCH]);
|
|
List<String> docIds = new ArrayList<>();
|
|
for( GroovyRowResult grr : result ) {
|
|
docIds.add(grr.get("dokuId"));
|
|
}
|
|
createAsyncJobForUpdates(d3, docBeforeUpdate, docIds, attribUpdate, "inheritLiefAttrib");
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* Vererbung von Eigenschaften
|
|
* @author Maschinenprojekt
|
|
* @see UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund werden Eigenschaften vererbt
|
|
*/
|
|
public static void inheritMProjAttributes( D3Interface d3, Document doc, Document gOldDoc, User user ) {
|
|
d3.log.info("Start Functions inheritMProjAttributes - Document ${doc.id}");
|
|
|
|
// Prüfung der Änderungen an der Akte (ddfValueChanged enhält alle DDF mit ; getrennt)
|
|
String ddfValueChanged = null;
|
|
boolean updateNeeded = false;
|
|
boolean knameChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_KNAME);
|
|
if(knameChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_KNAME);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_KNAME);
|
|
}
|
|
}
|
|
boolean knrChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_KNR);
|
|
if(knrChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_KNR);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_KNR);
|
|
}
|
|
}
|
|
boolean statusChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_STATUS);
|
|
if(statusChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_STATUS);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_STATUS);
|
|
}
|
|
}
|
|
boolean submChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_SUBMISSION);
|
|
if(submChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_SUBMISSION);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_SUBMISSION);
|
|
}
|
|
}
|
|
boolean salesgChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_SALESGROUP);
|
|
if(salesgChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_SALESGROUP);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_SALESGROUP);
|
|
}
|
|
}
|
|
boolean buchungskChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_BUCHKREIS68);
|
|
if(buchungskChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_BUCHKREIS68);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_BUCHKREIS68);
|
|
}
|
|
}
|
|
if(ddfValueChanged != null) {
|
|
updateNeeded = true;
|
|
}
|
|
|
|
d3.log.info("Process Functions inheritMProjAttributes - Document ${doc.id} - updateNeeded ${updateNeeded} ");
|
|
|
|
if(updateNeeded == true) {
|
|
// Vererbung auf die Akten soll synchron erfolgen, auf den Dokumenten ist asynchron erlaubt!
|
|
// Für die Aktualisierung der Dokumente gibt es ein seperates Skript!
|
|
def sqlStatementFolder =
|
|
"""SELECT doku_id as dokuId FROM firmen_spezifisch WHERE kue_dokuart IN
|
|
('${Const.gDTS_AKONT}', '${Const.gDTS_ALIKO}', '${Const.gDTS_AKOMM}', '${Const.gDTS_AKUKO}',
|
|
'${Const.gDTS_ALIEK}', '${Const.gDTS_APROR}', '${Const.gDTS_AMAUF}', '${Const.gDTS_AMPRO}', '${Const.gDTS_AMAKT}', '${Const.gDTS_AMNAC}',
|
|
'${Const.gDTS_AMSPE}', '${Const.gDTS_AMUPO}', '${Const.gDTS_AMCRA}', '${Const.gDTS_AMECR}', '${Const.gDTS_AMUSP}', '${Const.gDTS_AMEOP}')
|
|
AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '${doc.field[Const.gDDF_AUFTRNR]}'
|
|
ORDER BY kue_dokuart """;
|
|
List<GroovyRowResult> sqlResultFolder = d3.sql.executeAndGet(sqlStatementFolder);
|
|
|
|
if(sqlResultFolder != null) {
|
|
|
|
d3.log.info("Functions inheritMProjAttributes Anzahl Unterakten: " + sqlResultFolder.size());
|
|
|
|
for(GroovyRowResult grr : sqlResultFolder) {
|
|
String currDocId = grr.get("dokuId");
|
|
if(currDocId != null && !currDocId.equals("")) {
|
|
Document docTemp = d3.archive.getDocument(currDocId);
|
|
if(docTemp != null) {
|
|
if(knameChanged == true) {
|
|
docTemp.field[Const.gDDF_KNAME] = doc.field[Const.gDDF_KNAME];
|
|
}
|
|
if(knrChanged == true) {
|
|
docTemp.field[Const.gDDF_KNR] = doc.field[Const.gDDF_KNR];
|
|
}
|
|
if(statusChanged == true) {
|
|
docTemp.field[Const.gDDF_STATUS] = doc.field[Const.gDDF_STATUS];
|
|
}
|
|
if(submChanged == true) {
|
|
docTemp.field[Const.gDDF_SUBMISSION] = doc.field[Const.gDDF_SUBMISSION];
|
|
}
|
|
if(salesgChanged == true) {
|
|
docTemp.field[Const.gDDF_SALESGROUP] = doc.field[Const.gDDF_SALESGROUP];
|
|
}
|
|
if(buchungskChanged == true) {
|
|
for(int hCount60=1; hCount60 <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); hCount60++) {
|
|
docTemp.field[Const.gDDF_BUCHKREIS68][hCount60] = doc.field[Const.gDDF_BUCHKREIS68][hCount60];
|
|
}
|
|
}
|
|
d3.log.info("Functions inheritMProjAttributes Doc ${docTemp.id()} Synchron - Update: " + updateNeeded);
|
|
if(updateNeeded == true) {
|
|
try {
|
|
docTemp.updateAttributes(SystemSpecificConst.updatedUser, true);
|
|
} catch(Exception e) {
|
|
d3.log.error("Error Functions inheritMProjAttributes - Akte ${docTemp.id()} konnte nicht aktualisiert werden: " + e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritMProjAttributes Anzahl Akten: " + sqlResultFolder);
|
|
}
|
|
|
|
// Zur Aktualisierung der Dokumente -> Akte markieren für die Verarbeitung im JPL Skript check_massdata_changed_AMPRA!
|
|
try {
|
|
// Ermittlung der bisherigen Einträge
|
|
String sqlStatementMdc = "SELECT doc_id FROM mass_data_change WHERE doc_id = '${doc.id()}' "
|
|
List<GroovyRowResult> sqlResultMdc = d3.sql.executeAndGet(sqlStatementMdc);
|
|
int indexCounter = sqlResultMdc.size();
|
|
if(indexCounter == 0) {
|
|
String sqlStatementMdcInsert = "INSERT INTO mass_data_change (doc_id, field_name, field_index, field_value) VALUES ('${doc.id()}', 'MDC-AMPRA', 1, '${ddfValueChanged}') ";
|
|
int returnValue = d3.sql.execute(sqlStatementMdcInsert);
|
|
} else if(indexCounter >= 1) {
|
|
indexCounter = indexCounter + 1;
|
|
String sqlStatementMdcInsert = "INSERT INTO mass_data_change (doc_id, field_name, field_index, field_value) VALUES ('${doc.id()}', 'MDC-AMPRA', ${indexCounter}, '${ddfValueChanged}') ";
|
|
int returnValue = d3.sql.execute(sqlStatementMdcInsert);
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("Error Functions inheritMProjAttributes - Akte ${doc.id()} konnte nicht in die Tabelle mass_data_change ergänzt werden: " + e);
|
|
}
|
|
}
|
|
|
|
d3.log.info("End Functions inheritMProjAttributes");
|
|
}
|
|
|
|
/**
|
|
* Vererbung der Angebotsnummer bei Änderung auf die zugehörigen Dokumente
|
|
* @author
|
|
* @see UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund wird die Angebotsnummer vererbt
|
|
*/
|
|
public static void inheritOfferNo( D3Interface d3, Document doc, Document docOld, List<String> gAREGIChild, User user ) {
|
|
d3.log.info("Start Functions inheritOfferNo for docId = " + doc.id());
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritOfferNo Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritOfferNo", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", doc.field[Const.gDDF_ANNAME], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
|
|
} else {
|
|
|
|
d3.log.info("Functions inheritOfferNo Verarbeitung Asynchron");
|
|
|
|
def lOffNoNew = doc.field[Const.gDDF_OPPANNr]
|
|
def lOffNoNewShort = lOffNoNew.substring(0,4)
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_OPPANNr, lOffNoNew);
|
|
if( lOffNoNewShort.equals("Neue") || lOffNoNewShort.equals("9999") ) {
|
|
//mache nichts
|
|
} else {
|
|
attribUpdate.put(Const.gDDF_ADITTITLE, lOffNoNew);
|
|
}
|
|
createAsyncJobForUpdates(d3, doc, gAREGIChild, attribUpdate, "inheritOfferNo");
|
|
|
|
// 15.10.2021 Ermittlung der Vater-Akte über SQL Abfrage anstatt Link
|
|
// 18.11.2021 NEU: Kriterium hat Zeitstempel erhalten (siehe createOfferFolder + Transport NEU_Opportunity)
|
|
List<String> parents = new ArrayList<>();
|
|
String oldHauptOpp = docOld.field[Const.gDDF_HAUPTOPPANNR];
|
|
|
|
String sqlStatementFather = "SELECT doku_id FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_AUNTE}' AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${doc.field[Const.gDDF_OPPNUMMER]}' AND dok_dat_feld_${Const.gDDF_HAUPTOPPANNR} = '${oldHauptOpp}'";
|
|
List<GroovyRowResult> sqlResultFather = d3.sql.executeAndGet(sqlStatementFather);
|
|
if(sqlResultFather != null) {
|
|
for(GroovyRowResult grrFather : sqlResultFather) {
|
|
String fatherDocId = grrFather.get("doku_id");
|
|
if(fatherDocId != null && !fatherDocId.equals("")) {
|
|
parents.add(fatherDocId);
|
|
}
|
|
}
|
|
}
|
|
|
|
d3.log.info("Functions inheritOfferNo for docId fathers = " + parents);
|
|
|
|
//Aktualisiere auch die Hauptangebotsnummer auf der Angebotsvorgangsakte
|
|
// Abfrage und Anpassung der "Väter"
|
|
//List<String> parents = d3.call.link_get_parents(doc.id(), "d3groovy")
|
|
if( parents != null && parents.size() > 0 ) {
|
|
//Hole dir die bisherige Hauptangebotsnummer vom Angebotsvorgang..
|
|
Document docTemp2 = d3.archive.getDocument(parents[0])
|
|
def lOffNoOld = docTemp2.field[Const.gDDF_HAUPTOPPANNR]
|
|
String[] splittedString = lOffNoNew.split("\\.")
|
|
if(splittedString != null && splittedString.size() > 0) {
|
|
lOffNoNew = splittedString[0].trim()
|
|
//...Schneide die neue Nummer so, das nur die ersten vier Zeichen für eine Verprobung auf "Neue Angebotsversion" verbleiben
|
|
lOffNoNewShort = lOffNoNew.substring(0,4)
|
|
//... Wenn die Nummer sich nicht geändert hat, oder eine neue Angebotsversion erstellt wurde, ...
|
|
if( lOffNoOld.equals(lOffNoNew) || lOffNoNewShort.equals("Neue") ) {
|
|
//...mache nichts...
|
|
} else {
|
|
//...ansonsten setze die Angebotsnummer als Hauptangebotsnummer auf den Angebotsvorgang
|
|
Map<Integer, Object> attribUpdate2 = new HashMap<>();
|
|
attribUpdate2.put(Const.gDDF_HAUPTOPPANNR, lOffNoNew);
|
|
createAsyncJobForUpdates(d3, doc, parents, attribUpdate2, "inheritOfferNo");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Vererbung der Attribute Submission und Hauptopportunity auf alles darunterliegenden Dokumente und Akten
|
|
* @author
|
|
* @see UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund werden Eigenschaften vererbt
|
|
*/
|
|
public static void inheritOppAttr( D3Interface d3, Document doc, Document gOldDoc, User user ) {
|
|
d3.log.info("Start Functions inheritOppAttr");
|
|
|
|
// Prüfung der Änderungen an der Akte (ddfValueChanged enhält alle DDF mit ; getrennt)
|
|
String ddfValueChanged = null;
|
|
boolean updateNeeded = false;
|
|
boolean knameChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_KNAME);
|
|
if(knameChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_KNAME);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_KNAME);
|
|
}
|
|
}
|
|
boolean knrChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_KNR);
|
|
if(knrChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_KNR);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_KNR);
|
|
}
|
|
}
|
|
boolean statusChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_STATUS);
|
|
if(statusChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_STATUS);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_STATUS);
|
|
}
|
|
}
|
|
boolean submChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_SUBMISSION);
|
|
if(submChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_SUBMISSION);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_SUBMISSION);
|
|
}
|
|
}
|
|
boolean salesgChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_SALESGROUP);
|
|
if(salesgChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_SALESGROUP);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_SALESGROUP);
|
|
}
|
|
}
|
|
boolean buchkChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_BUCHKREIS);
|
|
if(buchkChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_BUCHKREIS);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_BUCHKREIS);
|
|
}
|
|
}
|
|
boolean mainoppChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_HAUPTOPP);
|
|
if(mainoppChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_HAUPTOPP);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_HAUPTOPP);
|
|
}
|
|
}
|
|
boolean buchungskChanged = checkIfValueChanged(d3, doc, gOldDoc, Const.gDDF_BUCHKREIS68);
|
|
if(buchungskChanged == true) {
|
|
if(ddfValueChanged == null) {
|
|
ddfValueChanged = String.valueOf(Const.gDDF_BUCHKREIS68);
|
|
} else {
|
|
ddfValueChanged = ddfValueChanged + ";" + String.valueOf(Const.gDDF_BUCHKREIS68);
|
|
}
|
|
}
|
|
if(ddfValueChanged != null) {
|
|
updateNeeded = true;
|
|
}
|
|
|
|
d3.log.info("Process Functions inheritOppAttr - Document ${doc.id} - updateNeeded ${updateNeeded} ");
|
|
|
|
if(updateNeeded == true) {
|
|
|
|
String sqlStatement = """SELECT doku_id as dokuId
|
|
FROM firmen_spezifisch WHERE kue_dokuart IN (
|
|
'${Const.gDTS_AANGE}', '${Const.gDTS_AANGU}', '${Const.gDTS_AUNTE}', '${Const.gDTS_AREGI}',
|
|
'${Const.gDTS_AKOMM}', '${Const.gDTS_AKUKO}', '${Const.gDTS_AKONT}', '${Const.gDTS_ALIEK}',
|
|
'${Const.gDTS_ALIKO}', '${Const.gDTS_APROR}',
|
|
'${Const.gDTS_AMUPO}', '${Const.gDTS_AVERT}' )
|
|
AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${doc.field[Const.gDDF_OPPNUMMER]}' """;
|
|
List<GroovyRowResult> sqlResultFolder = d3.sql.executeAndGet(sqlStatement);
|
|
|
|
if(sqlResultFolder != null) {
|
|
d3.log.info("Functions inheritOppAttr Anzahl Akten: " + sqlResultFolder.size());
|
|
|
|
for(GroovyRowResult grr : sqlResultFolder) {
|
|
String currDocId = grr.get("dokuId");
|
|
|
|
if(currDocId != null && !currDocId.equals("")) {
|
|
|
|
Document docTemp = d3.archive.getDocument(currDocId);
|
|
if(docTemp != null) {
|
|
if(knameChanged == true) {
|
|
docTemp.field[Const.gDDF_KNAME] = doc.field[Const.gDDF_KNAME];
|
|
}
|
|
if(knrChanged == true) {
|
|
docTemp.field[Const.gDDF_KNR] = doc.field[Const.gDDF_KNR];
|
|
}
|
|
if(statusChanged == true) {
|
|
docTemp.field[Const.gDDF_STATUS] = doc.field[Const.gDDF_STATUS];
|
|
}
|
|
if(submChanged == true) {
|
|
docTemp.field[Const.gDDF_SUBMISSION] = doc.field[Const.gDDF_SUBMISSION];
|
|
}
|
|
if(salesgChanged == true) {
|
|
docTemp.field[Const.gDDF_SALESGROUP] = doc.field[Const.gDDF_SALESGROUP];
|
|
}
|
|
if(buchkChanged == true) {
|
|
docTemp.field[Const.gDDF_BUCHKREIS] = doc.field[Const.gDDF_BUCHKREIS];
|
|
}
|
|
if(mainoppChanged == true) {
|
|
docTemp.field[Const.gDDF_HAUPTOPP] = doc.field[Const.gDDF_HAUPTOPP];
|
|
}
|
|
if(buchungskChanged == true) {
|
|
for(int hCount60=1; hCount60 <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); hCount60++) {
|
|
docTemp.field[Const.gDDF_BUCHKREIS68][hCount60] = doc.field[Const.gDDF_BUCHKREIS68][hCount60];
|
|
}
|
|
}
|
|
d3.log.info("Functions inheritOppAttributes Doc ${docTemp.id()} Synchron - Update: " + updateNeeded);
|
|
if(updateNeeded == true) {
|
|
try {
|
|
docTemp.updateAttributes(SystemSpecificConst.updatedUser, true);
|
|
} catch(Exception e) {
|
|
d3.log.error("Error Functions inheritOppAttributes - Akte ${docTemp.id()} konnte nicht aktualisiert werden: " + e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritOppAttributes Anzahl Akten: " + sqlResultFolder);
|
|
}
|
|
|
|
// Zur Aktualisierung der Dokumente -> Akte markieren für die Verarbeitung im JPL Skript check_massdata_changed_AOPPU!
|
|
try {
|
|
// Ermittlung der bisherigen Einträge
|
|
String sqlStatementMdc = "SELECT doc_id FROM mass_data_change WHERE doc_id = '${doc.id()}' "
|
|
List<GroovyRowResult> sqlResultMdc = d3.sql.executeAndGet(sqlStatementMdc);
|
|
int indexCounter = sqlResultMdc.size();
|
|
if(indexCounter == 0) {
|
|
String sqlStatementMdcInsert = "INSERT INTO mass_data_change (doc_id, field_name, field_index, field_value) VALUES ('${doc.id()}', 'MDC-AOPPU', 1, '${ddfValueChanged}') ";
|
|
int returnValue = d3.sql.execute(sqlStatementMdcInsert);
|
|
} else if(indexCounter >= 1) {
|
|
indexCounter = indexCounter + 1;
|
|
String sqlStatementMdcInsert = "INSERT INTO mass_data_change (doc_id, field_name, field_index, field_value) VALUES ('${doc.id()}', 'MDC-AOPPU', ${indexCounter}, '${ddfValueChanged}') ";
|
|
int returnValue = d3.sql.execute(sqlStatementMdcInsert);
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("Error Functions inheritMProjAttributes - Akte ${doc.id()} konnte nicht in die Tabelle mass_data_change ergänzt werden: " + e);
|
|
}
|
|
|
|
}
|
|
d3.log.info("inheritOppAttr beendet");
|
|
}
|
|
|
|
/* 04.11.2019 Funktion wird bereits durch inheritOppAttr abgedeckt
|
|
public static inheritOPPValues( D3Interface d3, def childId, def fatherId ) {
|
|
Document docFather = d3.archive.getDocument(fatherId)
|
|
Document docChild = d3.archive.getDocument(childId)
|
|
def lOpportunity // gDDF_OPPNUMMER
|
|
def lHauptopportunity // gDDF_HAUPTOPP gDDF_OPPNUMMER
|
|
def lVerkaeufergruppe // gDDF_SALESGROUP
|
|
def lStatus // gDDF_STATUS
|
|
def lzustVerkaeufer // gDDF_RESPSALESMAN
|
|
String[] lIntercompany // gDDF_BUCHKREIS68
|
|
def lSubmission // gDDF_SUBMISSION
|
|
def lProzess // gDDF_PROZESSART
|
|
def lKundenNr // gDDF_KNR
|
|
def lKundenName // gDDF_KNAME
|
|
def lBuchungskreis // gDDF_BUCHKREIS
|
|
def lReturn
|
|
lOpportunity = docFather.field[Const.gDDF_OPPNUMMER] // gDDF_HAUPTOPP
|
|
lHauptopportunity = docFather.field[Const.gDDF_HAUPTOPP] // gDDF_HAUPTOPP
|
|
lVerkaeufergruppe = docFather.field[Const.gDDF_SALESGROUP] // gDDF_SALESGROUP
|
|
lStatus = docFather.field[Const.gDDF_STATUS] // gDDF_STATUS
|
|
lzustVerkaeufer = docFather.field[Const.gDDF_RESPSALESMAN] // gDDF_RESPSALESMAN
|
|
lSubmission = docFather.field[Const.gDDF_SUBMISSION] // gDDF_SUBMISSION
|
|
lProzess = docFather.field[Const.gDDF_PROZESS] // gDDF_PROZESSART
|
|
lKundenNr = docFather.field[Const.gDDF_KNR] // gDDF_KNR
|
|
lKundenName = docFather.field[Const.gDDF_KNAME] // gDDF_KNAME
|
|
lBuchungskreis = docFather.field[Const.gDDF_BUCHKREIS] // gDDF_BUCHKREIS
|
|
for(int lCount=1; lCount <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); lCount++) {
|
|
lIntercompany[lCount] = docFather.field[Const.gDDF_BUCHKREIS68][lCount]
|
|
docChild.field[Const.gDDF_BUCHKREIS68][lCount] = lIntercompany[lCount]
|
|
if( !lIntercompany[lCount].equals("") ) {
|
|
// d3.log.error( "lIntercompany[${lCount}]: ${lIntercompany[lCount]}" )
|
|
}
|
|
}
|
|
docChild.field[Const.gDDF_OPPNUMMER] = lOpportunity
|
|
docChild.field[Const.gDDF_HAUPTOPP] = lHauptopportunity
|
|
docChild.field[Const.gDDF_SALESGROUP] = lVerkaeufergruppe
|
|
docChild.field[Const.gDDF_STATUS] = lStatus
|
|
docChild.field[Const.gDDF_RESPSALESMAN] = lzustVerkaeufer
|
|
docChild.field[Const.gDDF_SUBMISSION] = lSubmission
|
|
docChild.field[Const.gDDF_PROZESS] = lProzess
|
|
docChild.field[Const.gDDF_KNR] = lKundenNr
|
|
docChild.field[Const.gDDF_KNAME] = lKundenName
|
|
docChild.field[Const.gDDF_BUCHKREIS] = lBuchungskreis
|
|
try {
|
|
docChild.updateAttributes("d3groovy", true)
|
|
// d3.log.error( "Erfolgreich Dokument ${childId} ")
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, docChild.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error( "Die Attribute der neuen Opportunity konnten nicht in das Dokument ${childId} geschrieben werden!")
|
|
}
|
|
// in JPL waren die Parameter alle geleert, daher immer default verwenden
|
|
d3.call.document_send_to_dsearch( childId, "", 0, "", false, "Fr", 0, "d3groovy")
|
|
}
|
|
*/
|
|
|
|
/**
|
|
*
|
|
* @author
|
|
* @see UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund werden Attribute vererbt
|
|
*/
|
|
public static void inheritOrgProjAttributes( D3Interface d3, Document doc, Document gOldDoc, User user, String projNo ) {
|
|
d3.log.info("Start Functions inheritOrgProjAttributes");
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritOrgProjAttributes Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritOrgProj", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", projNo, 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
|
|
} else {
|
|
d3.log.info("Functions inheritOrgProjAttributes Verarbeitung Asynchron");
|
|
def sqlStatement = "SELECT doku_id as DokuId FROM firmen_spezifisch WHERE (kue_dokuart = '${Const.gDTS_AMEIS}' OR kue_dokuart = '${Const.gDTS_DPROO}') AND dok_dat_feld_${Const.gDDF_PROJNR} = '${projNo}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
docIds.add(grr.get("DokuId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
def lProjNr = doc.field[Const.gDDF_PROJNR].substring(0,11)
|
|
attribUpdate.put(Const.gDDF_HAUPTPROJEKT, lProjNr);
|
|
attribUpdate.put(Const.gDDF_PROJNR, doc.field[Const.gDDF_PROJNR]);
|
|
attribUpdate.put(Const.gDDF_PROJTITLE, doc.field[Const.gDDF_PROJTITLE]);
|
|
attribUpdate.put(Const.gDDF_PROJLEITER, doc.field[Const.gDDF_PROJLEITER]);
|
|
attribUpdate.put(Const.gDDF_ORGPROJVERT, doc.field[Const.gDDF_ORGPROJVERT]);
|
|
attribUpdate.put(Const.gDDF_PROJVERKN, doc.field[Const.gDDF_PROJVERKN]);
|
|
attribUpdate.put(Const.gDDF_HAUPTPROJEKT, doc.field[Const.gDDF_HAUPTPROJEKT]);
|
|
List<String> listBuchungskreise = new ArrayList<>();
|
|
List<String> listProjber = new ArrayList<>();
|
|
for(int hCount60=1; hCount60 <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); hCount60++) {
|
|
listBuchungskreise.add(doc.field[Const.gDDF_BUCHKREIS68][hCount60]);
|
|
listProjber.add(doc.field[Const.gDDF_PROJBER][hCount60]);
|
|
}
|
|
attribUpdate.put(Const.gDDF_BUCHKREIS68, listBuchungskreise);
|
|
attribUpdate.put(Const.gDDF_PROJBER, listProjber);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritOrgProjAttributes");
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Vererbung von Eigenschaften für Teamsitzungsdokumente
|
|
* @author unterstützende Prozesse
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund werden Attribute vererbt
|
|
*/
|
|
public static void inheritTeamdoc( D3Interface d3, Document doc, def pUser) {
|
|
d3.log.info("Start Functions inheritTeamdoc");
|
|
|
|
def lCnt
|
|
def lDocID
|
|
def lAccess
|
|
def lCase = doc.field[Const.gDDF_EVENT]
|
|
|
|
def sqlStatement = "SELECT doku_id as lDocID FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_AREME}' AND dok_dat_feld_${Const.gDDF_EVENT} = '${lCase}'"
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null) {
|
|
lCnt = sqlResult.size()
|
|
|
|
if (lCnt == 1) {
|
|
lDocID = sqlResult.getAt(0).get("lDocID")
|
|
Document docTemp = d3.archive.getDocument(lDocID, pUser);
|
|
|
|
// Achtung: Hier handelt es sich jeweils um 60er Felder
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
doc.field[Const.gDDF_D3USER67][i] = docTemp.field[Const.gDDF_D3USER67][i]
|
|
doc.field[Const.gDDF_BUCHKREIS68][i] = docTemp.field[Const.gDDF_BUCHKREIS68][i]
|
|
doc.field[Const.gDDF_HAUPTFUNKTION][i] = docTemp.field[Const.gDDF_HAUPTFUNKTION][i]
|
|
}
|
|
|
|
doc.field[Const.gDDF_VORGANGSSTATUS] = docTemp.field[Const.gDDF_VORGANGSSTATUS]
|
|
doc.field[Const.gDDF_CASEOWNER] = docTemp.field[Const.gDDF_CASEOWNER]
|
|
doc.field[Const.gDDF_ZUGRIFF] = docTemp.field[Const.gDDF_ZUGRIFF]
|
|
try {
|
|
doc.updateAttributes("d3groovy", true)
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
}
|
|
} else {
|
|
d3.log.error("###-> Teamsitzungsakte nicht eindeutig erkannt")
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Vererbung der Verkaufsphase auf die Dokumente einer Opportunity beim Import
|
|
* @author Opportunity
|
|
* @see InsertEntry
|
|
* @return keine Rückgabe; im Hintergrund werden Attribute vererbt
|
|
*/
|
|
public static void inheritSalesProcess( D3Interface d3, Document doc ) {
|
|
d3.log.info("Start Functions inheritSalesProcess");
|
|
|
|
def lOppNr = doc.field[Const.gDDF_OPPNUMMER]
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_VKPHASE} as lSalesProc " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNr}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AOPPU}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null && sqlResult.size()> 0) {
|
|
def lSalesProc = sqlResult.getAt(0).get("lSalesProc")
|
|
doc.field[Const.gDDF_VKPHASE] = lSalesProc
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Vererbung relevanter Eigenschaften für den Service
|
|
* @author Service
|
|
* @see UpdateExit
|
|
* @return keine Rückgabe; im Hintergrund werden Attribute vererbt
|
|
*/
|
|
public static void inheritServiceAttributes( D3Interface d3, Document doc, Document oldDoc, DocumentType docType, User user ) {
|
|
d3.log.info("Start Functions inheritServiceAttributes");
|
|
|
|
if( checkIfValueChanged(d3, doc, oldDoc, Const.gDDF_KNR) == true ) {
|
|
|
|
// Kundennr wurde über SAP geändert
|
|
if(!doc.field[Const.gDDF_KNR].equals(oldDoc.field[Const.gDDF_KNR])) {
|
|
|
|
// Der Kundename muss über die Kundenakte ermittelt werden
|
|
String sqlStatementCustomerName = "SELECT dok_dat_feld_${Const.gDDF_KNAME} as custName FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_AKUND}' AND dok_dat_feld_${Const.gDDF_KNR} = '${doc.field[Const.gDDF_KNR]}'";
|
|
List<GroovyRowResult> sqlResultCustomerName = d3.sql.executeAndGet(sqlStatementCustomerName);
|
|
if(sqlResultCustomerName != null && sqlResultCustomerName.size() > 0) {
|
|
// Kundenname ist über die Kundennummer immer eindeutig
|
|
doc.field[Const.gDDF_KNAME] = sqlResultCustomerName.getAt(0).get("custName");
|
|
}
|
|
|
|
// Ermittlung aller Kinder zur Serviceakte
|
|
if(docType.getId().equals(Const.gDTS_ASEBE)) {
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_KNR Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServKunden", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DSEBE, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_BELEGNUMMER), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_BELEGNUMMER], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_KNR Verarbeitung Asynchron");
|
|
// anhand Belegnummer
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DSEBE}' AND dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${doc.field[Const.gDDF_BELEGNUMMER]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_KNAME, doc.field[Const.gDDF_KNAME]);
|
|
attribUpdate.put(Const.gDDF_KNR, doc.field[Const.gDDF_KNR]);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
}
|
|
|
|
} else if(docType.getId().equals(Const.gDTS_ASERE)) {
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_KNR Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServKunden", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DSERE, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_SRID), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_SRID], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_KNR Verarbeitung Asynchron");
|
|
// anhand SR_ID
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DSERE}' AND dok_dat_feld_${Const.gDDF_SRID} = '${doc.field[Const.gDDF_SRID]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_KNAME, doc.field[Const.gDDF_KNAME]);
|
|
attribUpdate.put(Const.gDDF_KNR, doc.field[Const.gDDF_KNR]);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
}
|
|
|
|
} else if(docType.getId().equals(Const.gDTS_AEQUI)) {
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_KNR Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServKunden", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DEQUI, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_EQUIPMENT), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_EQUIPMENT], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_KNR Verarbeitung Asynchron");
|
|
// anhand Equipent No
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DEQUI}' AND dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${doc.field[Const.gDDF_EQUIPMENT]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_KNAME, doc.field[Const.gDDF_KNAME]);
|
|
attribUpdate.put(Const.gDDF_KNR, doc.field[Const.gDDF_KNR]);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( checkIfValueChanged(d3, doc, oldDoc, Const.gDDF_PROZESS) == true ) {
|
|
|
|
// Prozess wurde über SAP geändert
|
|
if(!doc.field[Const.gDDF_PROZESS].equals(oldDoc.field[Const.gDDF_PROZESS])) {
|
|
|
|
// Ermittlung aller Kinder zur Serviceakte
|
|
if(docType.getId().equals(Const.gDTS_ASEBE)) {
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_PROZESS Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServProzess", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DSEBE, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_BELEGNUMMER), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_BELEGNUMMER], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_PROZESS Verarbeitung Asynchron");
|
|
// anhand Belegnummer
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DSEBE}' AND dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${doc.field[Const.gDDF_BELEGNUMMER]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_PROZESS, doc.field[Const.gDDF_PROZESS]);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
|
|
}
|
|
|
|
} else if(docType.getId().equals(Const.gDTS_ASERE)) {
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_PROZESS Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServProzess", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DSERE, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_SRID), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_SRID], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_PROZESS Verarbeitung Asynchron");
|
|
// anhand SR_ID
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DSERE}' AND dok_dat_feld_${Const.gDDF_SRID} = '${doc.field[Const.gDDF_SRID]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_PROZESS, doc.field[Const.gDDF_PROZESS]);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
|
|
}
|
|
|
|
} else if(docType.getId().equals(Const.gDTS_AEQUI)) {
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_PROZESS Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServProzess", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DEQUI, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_EQUIPMENT), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_EQUIPMENT], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_PROZESS Verarbeitung Asynchron");
|
|
// anhand Equipment No
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DEQUI}' AND dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${doc.field[Const.gDDF_EQUIPMENT]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_PROZESS, doc.field[Const.gDDF_PROZESS]);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// Vererbung der Submission gemäß E-Mail vom 05.08.2020
|
|
if( checkIfValueChanged(d3, doc, oldDoc, Const.gDDF_SUBMISSION) == true ) {
|
|
|
|
if( docType.getId().equals(Const.gDTS_ASEBE) ) {
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_SUBMISSION Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServSubmission", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DSEBE, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_BELEGNUMMER), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_BELEGNUMMER], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_SUBMISSION Verarbeitung Asynchron");
|
|
// Ermittlung aller Kinder zur Serviceakte anhand Belegnummer
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DSEBE}' AND dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${doc.field[Const.gDDF_BELEGNUMMER]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_SUBMISSION, doc.field[Const.gDDF_SUBMISSION]);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
}
|
|
|
|
} else if(docType.getId().equals(Const.gDTS_AEQUI)) {
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_SUBMISSION Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServSubmission", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DEQUI, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_EQUIPMENT), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_EQUIPMENT], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_SUBMISSION Verarbeitung Asynchron");
|
|
// Ermittlung aller Kinder zur Equipmenteakte anhand Equipment No
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DEQUI}' AND dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${doc.field[Const.gDDF_EQUIPMENT]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_SUBMISSION, doc.field[Const.gDDF_SUBMISSION]);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Vererbung der Regionalorganisation gemäß E-Mail vom 05.08.2020
|
|
if( checkIfValueChanged(d3, doc, oldDoc, Const.gDDF_REGIONALORG) == true ) {
|
|
|
|
// Ermittlung aller Kinder zur Serviceakte
|
|
if(docType.getId().equals(Const.gDTS_ASEBE)) {
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_REGIONALORG Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServRegionalorg", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DSEBE, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_BELEGNUMMER), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_BELEGNUMMER], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_REGIONALORG Verarbeitung Asynchron");
|
|
// anhand Belegnummer
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DSEBE}' AND dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${doc.field[Const.gDDF_BELEGNUMMER]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
List<String> listRegionalorg = new ArrayList<>();
|
|
for(int i = 1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
listRegionalorg.add(doc.field[Const.gDDF_REGIONALORG][i]);
|
|
}
|
|
attribUpdate.put(Const.gDDF_REGIONALORG, listRegionalorg);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
|
|
}
|
|
|
|
} else if(docType.getId().equals(Const.gDTS_ASERE)) {
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_REGIONALORG Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServRegionalorg", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DSERE, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_SRID), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_SRID], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_REGIONALORG Verarbeitung Asynchron");
|
|
// anhand SR_ID
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DSERE}' AND dok_dat_feld_${Const.gDDF_SRID} = '${doc.field[Const.gDDF_SRID]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
List<String> listRegionalorg = new ArrayList<>();
|
|
for(int i = 1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
listRegionalorg.add(doc.field[Const.gDDF_REGIONALORG][i]);
|
|
}
|
|
attribUpdate.put(Const.gDDF_REGIONALORG, listRegionalorg);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
}
|
|
|
|
} else if(docType.getId().equals(Const.gDTS_AEQUI)) {
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_REGIONALORG Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritServRegionalorg", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", Const.gDTS_DEQUI, 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", String.valueOf(Const.gDDF_EQUIPMENT), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[4]", doc.field[Const.gDDF_EQUIPMENT], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
} else {
|
|
d3.log.info("Functions inheritServiceAttributes gDDF_REGIONALORG Verarbeitung Asynchron");
|
|
// anhand Equipment No
|
|
String sqlStatementChildren = "SELECT doku_id as dokId FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_DEQUI}' AND dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${doc.field[Const.gDDF_EQUIPMENT]}'";
|
|
List<GroovyRowResult> sqlResultChildren = d3.sql.executeAndGet(sqlStatementChildren);
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResultChildren) {
|
|
docIds.add(grr.get("dokId"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
List<String> listRegionalorg = new ArrayList<>();
|
|
for(int i = 1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
listRegionalorg.add(doc.field[Const.gDDF_REGIONALORG][i]);
|
|
}
|
|
attribUpdate.put(Const.gDDF_REGIONALORG, listRegionalorg);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritServiceAttributes");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Vererbung eines neuen Kundenamens und der Nummer auf alle darunterliegenden Dokumente und Akten
|
|
* @author
|
|
* @see UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund werden Attribute vererbt
|
|
*/
|
|
public static void inheritKInfoNew(D3Interface d3, Document doc, User user) {
|
|
d3.log.info("Start Functions inheritKInfoNew");
|
|
|
|
if( SystemSpecificConst.workWithAsyncJplForMassDataUpdate == true ) {
|
|
d3.log.info("Functions inheritOppAttr Verarbeitung JPL Asynchron");
|
|
try {
|
|
d3.call.d3async_job_open(doc.id(), "CUJ001", "d3groovy");
|
|
d3.call.d3async_job_set_attribute("hook_function", "gyInheritKInfoNew", 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[1]", doc.id(), 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[2]", doc.field[Const.gDDF_KNAME], 0);
|
|
d3.call.d3async_job_set_attribute("custom_job_par[3]", doc.field[Const.gDDF_KNR], 0);
|
|
d3.call.d3async_job_close();
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "UPD-Job konnte nicht erstellt werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error("UPD-Job konnte nicht erstellt werden = " + e);
|
|
}
|
|
|
|
} else {
|
|
d3.log.info("Functions inheritOppAttr Verarbeitung Asynchron");
|
|
def lDokIdOppCount
|
|
def lOppNr = doc.field[Const.gDDF_OPPNUMMER]
|
|
def lReturn
|
|
def sqlStatement = "SELECT doku_id as lDokIdOpp " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNr}' " +
|
|
"AND kue_dokuart <> '${Const.gDTS_AOPPU}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
lDokIdOppCount = sqlResult.size()
|
|
List<String> docIds = new ArrayList<>();
|
|
for(GroovyRowResult grr : sqlResult) {
|
|
docIds.add(grr.get("lDokIdOpp"));
|
|
}
|
|
Map<Integer, Object> attribUpdate = new HashMap<>();
|
|
attribUpdate.put(Const.gDDF_KNAME, doc.field[Const.gDDF_KNAME]);
|
|
attribUpdate.put(Const.gDDF_KNR, doc.field[Const.gDDF_KNR]);
|
|
createAsyncJobForUpdates(d3, doc, docIds, attribUpdate, "inheritKInfoNew");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Manuellen Job an den Rendition Server senden
|
|
* @author allgemeine Hilfsfunktion
|
|
* @see NewVersionExit
|
|
* @return Liefert numerisch zurück ob die Erstellung des RenderJobs erfolgreich war
|
|
*/
|
|
public static int renderDocument(D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions renderDocument");
|
|
|
|
String source = null; // Optional
|
|
String destination = null; // Optional
|
|
byte render_option = 2; // PDF Datei erzeugen
|
|
boolean ocr = false; // keine Verschlagwortung
|
|
boolean asynchronous = false; // obsolete
|
|
boolean replace_doc = false; // Render-Dokument ersetzt NICHT das Stammdokument
|
|
boolean overwrite = false; // Zieldatei soll NICHT ersetzt werden
|
|
String doc_id = doc.id(); // Dokument-ID zu dem ein abhängiges Dokument erzeugt werden soll
|
|
String user_name = null; // Benutzer in dessen Name der Aufruf efolgt -> auführende Benutzer
|
|
String doc_status = null; // Status der Version die gerendert werden soll -> aktuelle Version
|
|
int archiv_index = 0; // Index der Achrivversion, nur bei Status Archiv notwendig
|
|
String prio = "normal";
|
|
try {
|
|
return d3.call.document_render(source, destination, render_option, ocr, asynchronous, replace_doc, overwrite, doc_id, user_name, doc_status, archiv_index, prio);
|
|
} catch(Exception e) {
|
|
d3.log.error("renderDocument - Exception = " + e);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Versenden einer E-Mail, wenn das Dokument "empfohlen" wurde
|
|
* @author unterstützende Prozesse
|
|
* @see InsertExit, UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund wird eine E-Mail verschickt
|
|
*/
|
|
public static void sendMailRecom(D3Interface d3, Document doc, String pUser) {
|
|
d3.log.info("Start Functions sendMailRecom");
|
|
|
|
List<String> emailRecipients = new ArrayList<>();
|
|
def lUsername
|
|
def lMail
|
|
def lCnt
|
|
def h_ReturnValue
|
|
def h_RecipientUser = "" // Empfänger
|
|
def lCaption = doc.getCaption()
|
|
def h_SubjectText = "Das folgende Dokument ${lCaption} wurde Ihnen empfohlen." // Betreff der Email
|
|
def h_DokId = doc.id() // zu versendendes zu verlinkendes Dokument
|
|
def h_AttachDokId = true // Dokument soll verlinkt werden
|
|
def h_Sender = "" // Absender
|
|
def h_BodyFile = SystemSpecificConst.gBodyfile
|
|
def h_MailFormat = "html" // Formatierten Text verschicken
|
|
def h_CCRecipientUser = "" // Empfänger einer eMail-Kopie (CC)
|
|
def h_BCCRecipientUser = "" // Empfänger versteckter eMail- Kopie (BCC)
|
|
def h_AttachFile = "" // anzuhängende Datei
|
|
def h_AttachDep = "" // anzuhängende abhängige Dateien
|
|
def h_DocStatus = "Fr"
|
|
def h_ArchiveIndex = 0
|
|
def h_bodystring = "<font face=\"arial\">Das Dokument ${lCaption} wurde als interessant für Sie markiert. Klicken Sie auf den folgenden Link, um das Dokument anzuschauen:<br></font>"
|
|
// def h_bodystring = api_str_to_utf8("<font face=\"arial\">Das Dokument ${lCaption} wurde als interessant für Sie markiert. Klicken Sie auf den folgenden Link, um das Dokument anzuschauen\:</font><br>")
|
|
def h_d3onestring = SystemSpecificConst.gD3oneString + doc.id() + "><font face=\"arial\">Link</font></a>"
|
|
|
|
// JPL -> call api_function("file_delete", h_BodyFile)
|
|
File bodyFileDel = new File(h_BodyFile)
|
|
bodyFileDel.delete()
|
|
// JPL -> call api_function("file_add_string", h_BodyFile, UTF8_BOM, "OVERWRITE")
|
|
// JPL -> call api_function("file_add_line", h_BodyFile, h_bodystring, "APPEND")
|
|
// JPL -> call api_function("file_add_line", h_BodyFile, h_d3onestring, "APPEND")
|
|
File bodyFile = new File(h_BodyFile)
|
|
bodyFile.append( h_bodystring )
|
|
bodyFile.append( h_d3onestring )
|
|
|
|
def sqlStatement = "SELECT email as lMail FROM benutzer WHERE benutzername = '${pUser}'"
|
|
GroovyRowResult grr = d3.sql.firstRow(sqlStatement)
|
|
if( grr != null ) {
|
|
lMail = grr.get("lMail")
|
|
}
|
|
|
|
if(lMail != null && !lMail.equals("")) {
|
|
h_Sender = pUser
|
|
} else {
|
|
h_Sender = "d3_mailser"
|
|
}
|
|
|
|
for(int i = 1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if(doc.field[Const.gDDF_EMPFEHLUNG][i] != null) {
|
|
String[] splittedString = doc.field[Const.gDDF_EMPFEHLUNG][i].split("\\(")
|
|
if(splittedString != null && splittedString.size() > 0) {
|
|
def sqlStatementSec = "SELECT benutzername as lUsername FROM benutzer WHERE realname like '%${splittedString[0].trim()}%'"
|
|
List<GroovyRowResult> sqlResultSec = d3.sql.executeAndGet(sqlStatementSec)
|
|
if( sqlResultSec != null && sqlResultSec.size() > 0 ) {
|
|
lCnt = sqlResultSec.size();
|
|
lUsername = sqlResultSec.getAt(0).get("lUsername");
|
|
}
|
|
}
|
|
if(lCnt == 1) {
|
|
// Funktion zum versenden einer E-Mail
|
|
emailRecipients.add(lUsername)
|
|
}
|
|
}
|
|
}
|
|
|
|
for( String recipient : emailRecipients ) {
|
|
// JPL -> h_ReturnValue = api_function ("send_email", h_RecipientUser, h_SubjectText, "", h_DokId, h_Sender, h_BodyFile, h_MailFormat, h_AttachDokId, h_DocStatus, h_ArchiveIndex, h_AttachDep, h_AttachFile, 1, 0, 0)
|
|
h_ReturnValue = d3.call.send_email(recipient, h_SubjectText, null, h_DokId, h_Sender, bodyFile.absolutePath, h_MailFormat, h_AttachDokId, h_DocStatus, h_ArchiveIndex, h_AttachDep, h_AttachFile, false, false, false);
|
|
d3.log.info("EMail Returnwert ${h_ReturnValue}")
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Befüllung "Zusatztitel" anhand Opportunitynummer
|
|
* @author Opportunity
|
|
* @see InsertEntry, NewVersionEntry, UpdateAttributEntry
|
|
* @return keine Rückgabe; im Hintergrund wird "Zusatztitel" gefüllt
|
|
*/
|
|
public static void setAdditionalTitle( D3Interface d3, Document doc ) {
|
|
d3.log.info("Start Functions setAdditionalTitle");
|
|
|
|
def lOffNo = doc.field[Const.gDDF_OPPANNr]
|
|
if(lOffNo != null && !lOffNo.equals("")) {
|
|
def lOffNoShort = lOffNo.substring(0,4)
|
|
if( lOffNoShort.equals("Neue") || lOffNoShort.equals("9999") ) {
|
|
doc.field[Const.gDDF_ADITTITLE] = ""
|
|
} else {
|
|
doc.field[Const.gDDF_ADITTITLE] = lOffNo;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ermittlung der Eigenschaft "Betreff" über die Administrative Akte
|
|
* @author Maschinenprojekt
|
|
* @see InsertExit
|
|
* @return keine Rückgabe; im Hintergrund wird "Betreff" bzw. "Akte" gefüllt
|
|
*/
|
|
public static void setAttributSubject(D3Interface d3, Document doc , DocumentType docType, String userId) {
|
|
d3.log.info("Start Functions setAttributSubject");
|
|
|
|
if (( docType.getId().equals(Const.gDTS_DMAUF) || docType.getId().equals(Const.gDTS_DMDOK) ||
|
|
docType.getId().equals(Const.gDTS_DMSPE) || docType.getId().equals(Const.gDTS_DPRST) ||
|
|
docType.getId().equals(Const.gDTS_DMECR) || docType.getId().equals(Const.gDTS_DLIMA) || docType.getId().equals(Const.gDTS_DKUMA) ) &&
|
|
( !doc.field[Const.gDDF_DOKGROUP].equals(Const.gDG_ECRChangeOrder) && !doc.field[Const.gDDF_DOKGROUP].equals(Const.gDG_Medien) && (doc.field[Const.gDDF_SUBJECT].equals("") || doc.field[Const.gDDF_SUBJECT] == null) ) ) {
|
|
|
|
def lAndClause = "";
|
|
def lSubject = "";
|
|
def lDokGroup = doc.field[Const.gDDF_DOKGROUP];
|
|
def lProcess = doc.field[Const.gDDF_PROZESS];
|
|
|
|
if ( docType.getId().equals(Const.gDTS_DPRST) && (!lProcess.equals("") && lProcess != null ) ) {
|
|
lAndClause = "and dok_dat_feld_${Const.gDDF_PROZESS} = '${lProcess}'"
|
|
}
|
|
else if ( docType.getId().equals(Const.gDTS_DPRST) && (!doc.field[Const.gDDF_AUFTRNR].equals("") && doc.field[Const.gDDF_AUFTRNR] != null) ) {
|
|
lAndClause = "and dok_dat_feld_${Const.gDDF_PROZESS} = '0202'"
|
|
} else if ( docType.getId().equals(Const.gDTS_DPRST) && (!doc.field[Const.gDDF_OPPNUMMER].equals("") && doc.field[Const.gDDF_OPPNUMMER] != null) ) {
|
|
lAndClause = "and dok_dat_feld_${Const.gDDF_PROZESS} = '0201'"
|
|
}
|
|
|
|
// 31.07.2017 Hinweis: Hier kann nur ein Wert zurückkommen, da es eine fachlich gepflegte administrative Akte ist.
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_SUBJECT} as lSubject " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_REGISTER} = '${lDokGroup}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_ANWENDUNGSFALL} = '${docType.getId()}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AAFOL}' ${lAndClause} "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if(sqlResult != null && sqlResult.size() > 0) {
|
|
lSubject = sqlResult.getAt(0).get("lSubject");
|
|
|
|
doc.field[Const.gDDF_SUBJECT] = lSubject;
|
|
try {
|
|
doc.updateAttributes(userId, true);
|
|
} catch( Exception e ) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e;
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Befüllung der "internen Version"
|
|
* @author Opportunity, Maschinenprojekt, Entwicklungsprojekt, Kundenmanagement, Lieferantenmanagement, Schulung
|
|
* @see InsertExit, NewVersionExit, ReleaseExit, DeleteExit
|
|
* @return keine Rückgabe; im Hintergrund wird die "interne Version" gefüllt
|
|
*/
|
|
public static void setInternalVersion( D3Interface d3, String docId ) {
|
|
d3.log.info("Start Functions setInternalVersion");
|
|
|
|
// https://jira.d-velop.de/browse/OPG-2024 Erstellung Hook zur Füllung des Attributs "interne Version" mit der Versionsinformation des d.3 Dokuments
|
|
// Technikdokumenten (DMDOK) - DDF 88 soll mit der aktuellen Versionsnummer befüllt werden
|
|
|
|
def sqlStatement = "SELECT doc_id " +
|
|
"FROM doc_versions " +
|
|
"WHERE doc_id = '${docId}' " +
|
|
"AND doc_state IS NOT NULL "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
|
|
// d3.log.error( "setInternalVersion: ${sqlResult.size()}" )
|
|
Document doc;
|
|
try {
|
|
doc = d3.archive.getDocument(docId)
|
|
doc.field[Const.gDDF_VERSIONINTERN] = sqlResult.size()
|
|
doc.updateAttributes("d3groovy", true)
|
|
} catch(D3Exception e) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.info( "setInternalVersion - Dokument ( " + docId + " )" + " konnte nicht ermittelt werden" )
|
|
}
|
|
|
|
d3.log.info( "setInternalVersion - ENDE ( " + docId + " )" )
|
|
|
|
}
|
|
|
|
/**
|
|
* Erstellung von Teilvorgangsakten gemäß Änderung an der Hauptvorgangsakte. Ggf Eintragung der Vorgangsnummer an der Hauptvorgangsakte.
|
|
* @author Unterstützende Prozesse
|
|
* @see InsertExit, UpdateAttributExit
|
|
* @return keine Rückgabe; im Hintergrund wird eine Akte erstellt
|
|
*/
|
|
public static void setMainfolder( D3Interface d3, Document docNew ) {
|
|
d3.log.info("Start Functions setMainfolder");
|
|
|
|
Document doc = d3.archive.getDocument(docNew.id());
|
|
|
|
String[] teilVorNrArray = new String[2000];
|
|
String[] teilVorBezArray = new String[2000];
|
|
|
|
//Setzen der Hauptvorgangsnummer auf doku_id der Akte
|
|
if( doc.field[Const.gDDF_HAUPTVONR] == null) {
|
|
doc.field[Const.gDDF_HAUPTVONR] = doc.id()
|
|
}
|
|
|
|
int lAnzBez = countArrayElements(d3, doc, Const.gDDF_TEILVOBEZGEN);
|
|
int lAnzBezNr = countArrayElements(d3, doc, Const.gDDF_TEILVONRM);
|
|
|
|
def lOrdnungHaupt = doc.field[Const.gDDF_ORDNUNG]
|
|
|
|
if( lAnzBez > lAnzBezNr ) {
|
|
lAnzBezNr = lAnzBezNr + 1
|
|
|
|
//Erzeugen der Teilvorgangsnummern
|
|
for(int i=lAnzBezNr; i <= lAnzBez; i++) {
|
|
doc.field[Const.gDDF_TEILVONRM][i] = doc.field[Const.gDDF_HAUPTVONR] + "-" + i
|
|
teilVorNrArray[i] = doc.field[Const.gDDF_TEILVONRM][i]
|
|
teilVorBezArray[i] = doc.field[Const.gDDF_TEILVOBEZGEN][i]
|
|
}
|
|
|
|
def docIdTemp = doc.id();
|
|
//Erzeugen der Teilvorgangsakten
|
|
for(int i=lAnzBezNr; i <= lAnzBez; i++) {
|
|
String comlNum = fillNullValues(i, 4);
|
|
|
|
|
|
Document docTemp = d3.archive.newDocument()
|
|
docTemp.setType(Const.gDTS_ATEIL)
|
|
docTemp.setStatus("Freigabe")
|
|
docTemp.field[Const.gDDF_HAUPTVONR] = docIdTemp
|
|
docTemp.field[Const.gDDF_TEILVONR] = teilVorNrArray[i]
|
|
docTemp.field[Const.gDDF_TEILVOBEZ] = teilVorBezArray[i]
|
|
docTemp.field[Const.gDDF_ORDNUNG] = lOrdnungHaupt + "_" + comlNum
|
|
docTemp.field[Const.gDDF_VORGANGSSTATUS] = "offen"
|
|
|
|
def lRetVal = d3.call.folder_create(docTemp)
|
|
|
|
if(lRetVal != 0) {
|
|
d3.log.error("Teilvorgangsakte konnte nicht angelegt werden - ${lRetVal}")
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// 09.08.2021 imue: Update muss auf jeden Fall ausgeführt werden
|
|
try {
|
|
doc.updateAttributes("d3groovy", true);
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generierung einer eindeutigen Projektnummer bei der Anlage oder Aktualisierung einer Organisationsprojektakte
|
|
* @author Organisationsprojekt
|
|
* @see InsertEntry, UpdateEntry
|
|
* @return keine Rückgabe; im Hintergrund wird die Projektnummer hochgezählt
|
|
*/
|
|
public static void setNextProjnr( D3Interface d3, Document doc, def pDokDatFeld, def pLength, String entryPoint ) {
|
|
d3.log.info("Start Functions setNextProjnr");
|
|
|
|
if( doc.field[Const.gDDF_PROJVERKN] == null && entryPoint.equals("INSERT") ) {
|
|
|
|
// pDokuArt -> Dokumentart zur Grundlage der Ermittlung der Nummer
|
|
// pDokDatFeld -> Diesem Feld wird die Nummer zugewiesen (alphanum)
|
|
// plength -> Länge der Nummer (mit führenden Nullen)
|
|
|
|
// Variablen
|
|
def lfd_nr = ""
|
|
def puffer = 0
|
|
def stringNull = ""
|
|
|
|
SimpleDateFormat dateFormatYear = new SimpleDateFormat("yyyy");
|
|
String currentYear = dateFormatYear.format(new Date())
|
|
|
|
//Ermittle die höchste Projektnummer
|
|
def sqlStatement = "SELECT max(dok_dat_feld_${pDokDatFeld}) as lfd_nr " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${doc.getType().id()}' " +
|
|
"AND (dok_dat_feld_${pDokDatFeld} like 'OP-${currentYear}%') "
|
|
def sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if(sqlResult != null && sqlResult.size() > 0) {
|
|
lfd_nr = sqlResult.getAt(0).get("lfd_nr")
|
|
}
|
|
|
|
//Es wurde keine Projektnummer für dieses Jahr gefunden. Default = OP-2015-001-00
|
|
if( lfd_nr == null || lfd_nr.equals("") ) {
|
|
for(int i=1; i <= (pLength-1); i++) {
|
|
stringNull = stringNull + "0"
|
|
}
|
|
lfd_nr = "OP" + "-"+ currentYear + "-" + stringNull + "1" + "-" + "00"
|
|
doc.field[pDokDatFeld] = lfd_nr
|
|
|
|
} else {
|
|
//Es wurde eine Projektnummer gefunden
|
|
|
|
//Akutelle Nummer extrahieren
|
|
lfd_nr = lfd_nr.substring(8, 8+pLength)
|
|
//Aktuelle Nummer hochzählen
|
|
lfd_nr = getNextId(d3, lfd_nr, 3);
|
|
//Anzahl der Stellen der Nummer ermitteln
|
|
puffer = pLength - lfd_nr.length()
|
|
//Führende Nullen auffüllen
|
|
for(int i=1; i <= puffer; i++) {
|
|
stringNull = stringNull + "0"
|
|
}
|
|
//Neue Vertragsnummer zusammenstellen: Jahreszahl + Neue Nummer
|
|
lfd_nr = "OP" + "-" + currentYear + "-" + stringNull + lfd_nr + "-" + "00"
|
|
doc.field[pDokDatFeld] = lfd_nr
|
|
}
|
|
|
|
} else {
|
|
|
|
def lProjVerkalt = ""
|
|
def lProjVerkneu = doc.field[Const.gDDF_PROJVERKN]
|
|
|
|
def sqlStatementVerkn = "SELECT dok_dat_feld_${Const.gDDF_PROJVERKN} as lProjVerkalt " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE doku_id = '${doc.id()}'"
|
|
|
|
List<GroovyRowResult> sqlResultVerk = d3.sql.executeAndGet(sqlStatementVerkn)
|
|
if(sqlResultVerk != null && sqlResultVerk.size() > 0) {
|
|
lProjVerkalt = sqlResultVerk.getAt(0).get("lProjVerkalt")
|
|
}
|
|
|
|
if( (lProjVerkneu != null && !lProjVerkalt.equals(lProjVerkneu)) || entryPoint.equals("INSERT") ) {
|
|
|
|
//Anlage der nächst höheren Projektnummer bei Eingabe einer Projektverknüpfung
|
|
def lfd_nr = ""
|
|
def lfd_nr_o_suff = ""
|
|
def max_projno = ""
|
|
def max_projno_OP = ""
|
|
def max_projno_suff
|
|
|
|
lfd_nr = doc.field[Const.gDDF_PROJVERKN].substring(0,14)
|
|
lfd_nr_o_suff = lfd_nr.substring(0,11)
|
|
|
|
//Abfrage der höchsten Projektnummer zu einem Projekt
|
|
def sqlStatement = "SELECT max(dok_dat_feld_${pDokDatFeld}) as max_projno " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${pDokDatFeld} like ('${lfd_nr_o_suff}%') "
|
|
def sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if(sqlResult != null && sqlResult.size() > 0 ) {
|
|
max_projno = sqlResult.getAt(0).get("max_projno")
|
|
max_projno_OP = max_projno.substring(0, 11)
|
|
max_projno_suff = max_projno.substring(12, 14)
|
|
max_projno_suff = getNextId(d3, max_projno_suff, 2);
|
|
}
|
|
if(max_projno_OP != null && max_projno_suff != null) {
|
|
doc.field[pDokDatFeld] = max_projno_OP + "-" + max_projno_suff
|
|
}
|
|
// Neue Org Hauptprojekt muss auch gesplittet gesetzt werden
|
|
if(lfd_nr != null && !lfd_nr.equals("")) {
|
|
doc.field[Const.gDDF_PROJVERKN] = lfd_nr;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Inhalt eines Mehrfachfelds wird in ein Einfachfeld zusammengeschrieben
|
|
* @author Unterstützende Prozesse
|
|
* @see InsertEntry, UpdateAttributEntry, NewVersionEntry
|
|
* @return keine Rückgabe; im Hintergrund wird ein Bemerkungsfeld gefüllt
|
|
*/
|
|
public static void sixty2single(D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions sixty2single");
|
|
|
|
if( doc.getType().getId().equals(Const.gDTS_DLOEH) ) {
|
|
doc.setText(4,"")
|
|
|
|
for (int i = 1; i<=Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if( doc.field[Const.gDDF_SCHLAGWORT][i] != null && !doc.field[Const.gDDF_SCHLAGWORT][i].equals("") ) {
|
|
def tmp = doc.field[Const.gDDF_SCHLAGWORT][i]
|
|
if(tmp != null && !tmp.equals("")) {
|
|
if( doc.getText(4).equals("") || doc.getText(4) == null ) {
|
|
doc.setText(4, tmp)
|
|
} else {
|
|
doc.setText(4, doc.getText(4) + " I " + tmp)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Buchungskreis (WM 'Buchungskreis') ist zusammengesetzt aus Nummer und Text aus SAP
|
|
* @author Unterstützende Prozesse
|
|
* @see InsertEntry, SearchEntry
|
|
* @return Rückgabe ist die eindeutige Nummer
|
|
*/
|
|
public static String splitBuKrs(def lValue) {
|
|
if(lValue != null) {
|
|
String[] splittedString = lValue.split("\\|")
|
|
def lRetVal = splittedString.size()
|
|
if( lRetVal > 1 ) {
|
|
def newValue = splittedString[0].trim()
|
|
return newValue
|
|
} else {
|
|
return lValue
|
|
}
|
|
} else {
|
|
return lValue
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Split des zusammengesetzten Wertes Buchungskreis Nummer und Bezeichnung, nach Nummer
|
|
* @author
|
|
* @see InsertEntry, NewVersionEntry
|
|
* @return keine Rückgabe; im Hintergrund wird die Buchungskreis Nummer gesetzt
|
|
*/
|
|
public static int splitBuchungskreis(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitBuchungskreis");
|
|
|
|
// Ermittlung in welchen Dokumentarten die Eigenschaft Buchungskreis vorkommt (Einfachfeld und Mehrfachfeld)
|
|
def sqlStatementBK = "SELECT DISTINCT kue_dokuart as dokuArt " +
|
|
"FROM fispe_titel_dokuart " +
|
|
"WHERE repository_id = '${SystemSpecificConst.gBuchungskreisID}' " +
|
|
" OR repository_id = '${SystemSpecificConst.gBuchungskreiseID}' "
|
|
List<GroovyRowResult> sqlResultBK = d3.sql.executeAndGet(sqlStatementBK);
|
|
List<String> dokuartenBk = new ArrayList<>()
|
|
if(sqlResultBK != null) {
|
|
for(GroovyRowResult grr : sqlResultBK) {
|
|
dokuartenBk.add(grr.get("dokuArt"))
|
|
}
|
|
}
|
|
//Splitten des zusammengesetzten Strings Buchungskreis, Buchungskreistext nach Buchungskreis
|
|
if( dokuartenBk.contains(docType.getId()) ) {
|
|
if( doc.field[Const.gDDF_BUCHKREIS] != null && !doc.field[Const.gDDF_BUCHKREIS].equals("") ) {
|
|
def lBuchKr = doc.field[Const.gDDF_BUCHKREIS].substring(0,4)
|
|
doc.field[Const.gDDF_BUCHKREIS] = lBuchKr
|
|
}
|
|
// Split des Wertes für Intercompany
|
|
for( int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if( doc.field[Const.gDDF_BUCHKREIS68][i] != null && !doc.field[Const.gDDF_BUCHKREIS68][i].equals("") ) {
|
|
def lBuchKr68 = doc.field[Const.gDDF_BUCHKREIS68][i]
|
|
doc.field[Const.gDDF_BUCHKREIS68][i] = lBuchKr68.substring(0,4)
|
|
}
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
|
|
/**
|
|
* Split des zusammengesetzten Wertes für Endkundennummer oder Endkundenname
|
|
* @author
|
|
* @see SearchEntry
|
|
* @return keine Rückgabe; im Hintergrund wird der eingeutige Wert gesetzt
|
|
*/
|
|
public static void splitEndKunde(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitEndKunde");
|
|
|
|
//Splitten des zusammengesetzten Strings Kundenname und Kundennummer
|
|
if( doc.field[Const.gDDF_ENDKUNDENNR] != null || doc.field[Const.gDDF_ENDKUNDENAM] != null ) {
|
|
//Splitten des Endkundennamens und der Endkundennummer für die Suche
|
|
String[] splittedString
|
|
def lReturn = 0
|
|
if( doc.field[Const.gDDF_ENDKUNDENAM] != null ) {
|
|
splittedString = doc.field[Const.gDDF_ENDKUNDENAM].split("\\|")
|
|
if( splittedString != null ) {
|
|
lReturn = splittedString.size()
|
|
}
|
|
} else if( doc.field[Const.gDDF_ENDKUNDENNR] != null ) {
|
|
splittedString = doc.field[Const.gDDF_ENDKUNDENNR].split("\\|")
|
|
if( splittedString != null ) {
|
|
lReturn = splittedString.size()
|
|
}
|
|
}
|
|
if( lReturn > 1 ) {
|
|
doc.field[Const.gDDF_ENDKUNDENNR] = splittedString[0]
|
|
doc.field[Const.gDDF_ENDKUNDENAM] = ""
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Split des zusammengesetzten Wertes für Kundennummer oder Kundenname
|
|
* @author
|
|
* @see SearchEntry
|
|
* @return keine Rückgabe; im Hintergrund wird der eingeutige Wert gesetzt
|
|
*/
|
|
public static void splitKunde(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitKunde");
|
|
|
|
//Splitten des zusammengesetzten Strings Kundenname und Kundennummer
|
|
if( doc.field[Const.gDDF_KNR] != null || doc.field[Const.gDDF_KNAME] != null ) {
|
|
//Splitten des Kundennamens und der Kundennummer für die Suche
|
|
String[] splittedString
|
|
def lReturn = 0
|
|
if( doc.field[Const.gDDF_KNAME] != null ) {
|
|
splittedString = doc.field[Const.gDDF_KNAME].split("\\|")
|
|
if( splittedString != null ) {
|
|
lReturn = splittedString.size();
|
|
}
|
|
} else if( doc.field[Const.gDDF_KNR] != null ) {
|
|
splittedString = doc.field[Const.gDDF_KNR].split("\\|")
|
|
if( splittedString != null ) {
|
|
lReturn = splittedString.size()
|
|
}
|
|
}
|
|
if( lReturn > 1 ) {
|
|
doc.field[Const.gDDF_KNR] = splittedString[0]
|
|
doc.field[Const.gDDF_KNAME] = ""
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Splitten der Kontaktbeschreibung und Prüfung ob es sich um eine valide Kombination aus Lieferanten-Nr, Kontaktbeschreibung, Termin und Kategorie handelt
|
|
* @author Lieferantenmanagement
|
|
* @see Insert, Update, New Version
|
|
* @return Rückgabe ob die Änderung valide ist (0, -170)
|
|
*/
|
|
public static int splitLieferantenkontaktbeschreibung(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitLieferantenkontaktbeschreibung");
|
|
|
|
def lKontKategorie
|
|
def lReturn
|
|
def pRowCount
|
|
if( doc.field[Const.gDDF_KONTAKTBESCH] != null && !doc.field[Const.gDDF_KONTAKTBESCH].equals("") ) {
|
|
// Splitten der Beschreibung und Verteilung der Daten auf die entsprechenden Felder
|
|
// Auf diese Weise kann die nachfolgende Plausibilitäts-Prüfung universell (auch für manuelle Eingabe) erfolgen.
|
|
// call api_log_error( "Vor dem Split 2018 " ## dok_dat_feld[gDDF_KONTAKTBESCH] )
|
|
lReturn = doc.field[Const.gDDF_KONTAKTBESCH].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_KONTAKTBESCH].split("\\|")
|
|
if( splittedString != null && splittedString.size() == 3 ) {
|
|
def sqlStatement = "SELECT value_char_allowed as lKontKategorie FROM doc_field_val_lang WHERE predef_value_id = '${SystemSpecificConst.gPredValueIDKatLief}' AND value_char_transl = '${splittedString[1]}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
lKontKategorie = sqlResult.getAt(0).get("lKontKategorie")
|
|
try {
|
|
// Umwandlung des String Datums in Datentyp Timestamp für den Import notwendig
|
|
SimpleDateFormat dateFormat = new SimpleDateFormat("dd.MM.yyyy");
|
|
Date parsedDate = dateFormat.parse(splittedString[0].trim());
|
|
Timestamp timestamp = new java.sql.Timestamp(parsedDate.getTime());
|
|
doc.field[Const.gDDF_KONTAKTDATE] = timestamp
|
|
doc.field[Const.gDDF_LIEFAKTKAT] = lKontKategorie
|
|
doc.field[Const.gDDF_KONTAKTBESCH] = splittedString[2].trim()
|
|
} catch(Exception e) { //this generic but you can control another types of exception
|
|
// look the origin of excption
|
|
}
|
|
}
|
|
} else {
|
|
// korrekten ALIAS für die Kategorie ermitteln
|
|
def sqlStatement = "SELECT value_char_allowed as lKontKategorie FROM doc_field_val_lang WHERE predef_value_id = '${SystemSpecificConst.gPredValueIDKatLief}' AND ( value_char_transl = '${doc.field[Const.gDDF_KDAKTKAT]}' OR value_char_allowed = '${doc.field[Const.gDDF_KDAKTKAT]}' ) "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
lKontKategorie = sqlResult.getAt(0).get("lKontKategorie")
|
|
doc.field[Const.gDDF_LIEFAKTKAT] = lKontKategorie
|
|
}
|
|
def sqlStatement = "SELECT * " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ALONT}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KONTAKTDATE} = '${doc.field[Const.gDDF_KONTAKTDATE]}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_LIEFAKTKAT} = '${doc.field[Const.gDDF_LIEFAKTKAT]}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KONTAKTBESCH} = '${doc.field[Const.gDDF_KONTAKTBESCH]}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_LNR} = '${doc.field[Const.gDDF_LNR]}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
pRowCount = sqlResult.size()
|
|
|
|
if( pRowCount == 1 ) {
|
|
d3.log.info( "Alles OK" )
|
|
} else {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT021049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT021001)
|
|
}
|
|
d3.log.error( "Bitte geben Sie eine gültige Kombination aus Lieferant_Nr, Kontakt_Beschreibung, Kategorie und Termin ein oder wählen Sie eine Kontakt_Beschreibung aus der Auswahlliste." )
|
|
return -170
|
|
}
|
|
} else {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT021049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT021001)
|
|
}
|
|
d3.log.error( "Bitte geben Sie eine gültige Kombination aus Kontakt_Beschreibung, Kategorie und Termin ein oder wählen Sie eine Kontakt_Beschreibung aus der Auswahlliste." )
|
|
return -170
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see InsertEntry, ValidateUpdateEntry, NewVersionEntry
|
|
* @return
|
|
*/
|
|
public static int splitLieferant(D3Interface d3, Document doc, DocumentType docType, User user, String entryPoint, Document docBeforeUpdate ) {
|
|
d3.log.info("Start Functions splitLieferant = " + docType.id());
|
|
|
|
def lLFNr = doc.field[Const.gDDF_LNR]
|
|
def lLFName = doc.field[Const.gDDF_LNAME]
|
|
def lReturn
|
|
def lReturn2
|
|
def gTMPLFNr = ""
|
|
def userName = user.id();
|
|
|
|
|
|
// 25.11.2022 imue: Keine Einstiegspunkteingrenzung
|
|
if ( lLFNr != null && lLFName == null ) {
|
|
String[] splittedString = lLFNr.split("\\|")
|
|
lReturn = splittedString.size()
|
|
//Wenn Lieferantennummer ermittelt wurde, dann Lieferantennummer in Attributfeld schreiben
|
|
if( lReturn > 1 && splittedString[0] != null && splittedString[1] != null ) {
|
|
if ( !splittedString[0].equals("d3") ) {
|
|
// Hinweis 19.03.2018/dkle: Die Lieferantennummer darf für DLIKO und ALIKO nicht mehr aktualisiert werden, dies erfolgt nun per Aktenplan und ist nicht modifizierbar.
|
|
if( docType.getId().equals(Const.gDTS_DLIKO) ) {
|
|
gTMPLFNr = splittedString[0]
|
|
} else {
|
|
doc.field[Const.gDDF_LNR] = splittedString[0].trim();
|
|
}
|
|
}
|
|
if( !docType.getId().equals(Const.gDTS_DLIMA) && !docType.getId().equals(Const.gDTS_DLONT) ) {
|
|
// Hinweis: Bei Lieferantendokumenten und Lieferantenkontaktdokumenten darf nur die Lieferantennummer modifiziert werden. Aktualisierung des Names erfolgt per Aktenplan.
|
|
doc.field[Const.gDDF_LNAME] = splittedString[1].trim();
|
|
}
|
|
}
|
|
} else if ( lLFNr == null && lLFName != null ) {
|
|
String[] splittedString = lLFName.split("\\|")
|
|
lReturn = splittedString.size()
|
|
|
|
if(splittedString.size() >= 2) {
|
|
if ( lReturn > 1 && splittedString[0] != null && splittedString[1] != null ) {
|
|
if ( !splittedString[0].equals("d3") ) {
|
|
// Hinweis 19.03.2018/dkle: Die Lieferantennummer darf für DLIKO und ALIKO nicht mehr aktualisiert werden, dies erfolgt nun per Aktenplan und ist nicht modifizierbar.
|
|
if( docType.getId().equals(Const.gDTS_DLIKO) ) {
|
|
gTMPLFNr = splittedString[0]
|
|
} else {
|
|
doc.field[Const.gDDF_LNR] = splittedString[0].trim();
|
|
}
|
|
} else if( splittedString[0].equals("d3") && !docType.getId().equals(Const.gDTS_DLIKO) ) {
|
|
// Hinweis: Ausnahme Projektlieferantendokumente DLIKO, da die Lieferantennummer vererbt wird und nicht leer gesetzt werden darf
|
|
doc.field[Const.gDDF_LNR] = ""
|
|
}
|
|
if( !docType.getId().equals(Const.gDTS_DLIMA) && !docType.getId().equals(Const.gDTS_DLONT) && !docType.getId().equals(Const.gDTS_ALONT) ) {
|
|
// Hinweis: Bei Lieferantendokumenten und Lieferantenkontaktdokumenten darf nur die Lieferantennummer modifiziert werden. Aktualisierung des Names erfolgt per Aktenplan.
|
|
doc.field[Const.gDDF_LNAME] = splittedString[1].trim();
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if ( lLFNr != null && lLFName != null ) {
|
|
|
|
lReturn = lLFNr.indexOf("|")
|
|
lReturn2 = lLFName.indexOf("|")
|
|
|
|
|
|
if( lReturn > 0 && lReturn2 < 0 ) {
|
|
String[] splittedString = lLFNr.split("\\|")
|
|
lReturn = splittedString.size()
|
|
if ( lReturn > 0 && splittedString[0] != null && splittedString[1] != null ) {
|
|
if ( !splittedString[0].equals("d3") ) {
|
|
// Hinweis 19.03.2018/dkle: Die Lieferantennummer darf für DLIKO und ALIKO nicht mehr aktualisiert werden, dies erfolgt nun per Aktenplan und ist nicht modifizierbar.
|
|
if( docType.getId().equals(Const.gDTS_DLIKO) ) {
|
|
gTMPLFNr = splittedString[0]
|
|
} else {
|
|
doc.field[Const.gDDF_LNR] = splittedString[0].trim();
|
|
}
|
|
} else if( docType.getId().equals(Const.gDTS_DLIKO) ) {
|
|
// Hinweis: Ausnahme Projektlieferantendokumente DLIKO, da die Lieferantennummer vererbt wird und nicht leer gesetzt werden darf
|
|
doc.field[Const.gDDF_LNR] = ""
|
|
}
|
|
if( !docType.getId().equals(Const.gDTS_DLIMA) && !docType.getId().equals(Const.gDTS_DLONT) && !docType.getId().equals(Const.gDTS_ALONT) ) {
|
|
// Hinweis: Bei diesen Dokumentarten darf nur die Lieferantennummer modifiziert werden. Aktualisierung des Names erfolgt per Aktenplan.
|
|
// - Lieferantendokumenten DLIMA
|
|
// - Lieferantenkontaktdokumenten DLONT
|
|
// - Lieferantenkontakt ALONT
|
|
doc.field[Const.gDDF_LNAME] = splittedString[1].trim();
|
|
}
|
|
}
|
|
} else if( lReturn < 0 && lReturn2 > 0 ) {
|
|
String[] splittedString = lLFName.split("\\|")
|
|
lReturn = splittedString.size()
|
|
if ( lReturn > 0 && splittedString[0] != null && splittedString[1] != null) {
|
|
if ( !splittedString[0].equals("d3") ) {
|
|
// Hinweis 19.03.2018/dkle: Die Lieferantennummer darf für DLIKO und ALIKO nicht mehr aktualisiert werden, dies erfolgt nun per Aktenplan und ist nicht modifizierbar.
|
|
if( docType.getId().equals(Const.gDTS_DLIKO) ) {
|
|
gTMPLFNr = splittedString[0]
|
|
// d3.log.error( "gTMPLFNr: " + gTMPLFNr )
|
|
} else {
|
|
doc.field[Const.gDDF_LNR] = splittedString[0].trim();
|
|
}
|
|
} else if( splittedString[0].equals("d3") && !docType.getId().equals(Const.gDTS_DLIKO) ) {
|
|
// Hinweis: Ausnahme Projektlieferantendokumente DLIKO, da die Lieferantennummer vererbt wird und nicht leer gesetzt werden darf
|
|
doc.field[Const.gDDF_LNR] = ""
|
|
}
|
|
if( !docType.getId().equals(Const.gDTS_DLIMA) && !docType.getId().equals(Const.gDTS_DLONT) && !docType.getId().equals(Const.gDTS_ALONT) ) {
|
|
// Hinweis: Bei Lieferantendokumenten und Lieferantenkontaktdokumenten darf nur die Lieferantennummer modifiziert werden. Aktualisierung des Names erfolgt per Aktenplan.
|
|
doc.field[Const.gDDF_LNAME] = splittedString[1].trim();
|
|
}
|
|
}
|
|
} else if( lReturn > 0 && lReturn2 > 0 && !user.isMemberOfGroup( Const.gTECHNICAL_GROUP )) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", "Bitte wählen Sie entweder den Lieferantennamen oder die Lieferantennummer aus der Liste aus, oder geben Sie es manuell ein.")
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", "Please choose either a Customer No. or a Customer Name from the Dropdown Box or provide them manually.")
|
|
}
|
|
d3.log.error( "Bitte wählen Sie entweder den Lieferantennamen oder die Lieferantennummer aus oder geben Sie es manuell ein." )
|
|
return -170
|
|
|
|
// Differenz zu JPL: Umstellung von nicht zutreffenden Dokumentarten auf nur noch zutreffende
|
|
} else if( lReturn < 0 && lReturn2 < 0 && ( docType.getId().equals(Const.gDTS_ALIKO) || docType.getId().equals(Const.gDTS_DLIKO) ) && !entryPoint.toLowerCase().equals("insert") ) {
|
|
if(userName.equals("d3_async") || docType.getId().equals(Const.gDTS_ALIKO)) {
|
|
// 07.03.2023 imue: Anpassung weil der Async ein Update triggert und die Lieferantennummer ungewollt leert
|
|
// 07.08.2023 imue: Es ist nun gewünscht an der Projektlieferantakte die Lieferantenangaben im Notfall ändern zu können
|
|
} else {
|
|
doc.field[Const.gDDF_LNR] = ""
|
|
}
|
|
}
|
|
}
|
|
|
|
if( ( doc.field[Const.gDDF_LNAME] == null || doc.field[Const.gDDF_LNAME].equals("")) &&
|
|
!docType.getId().equals(Const.gDTS_DMEOP) &&!docType.getId().equals(Const.gDTS_DMEOP) &&
|
|
!docType.getId().equals(Const.gDTS_DLONT) && !docType.getId().equals(Const.gDTS_DLIMA) &&
|
|
!docType.getId().equals(Const.gDTS_DERZ1) && !docType.getId().equals(Const.gDTS_ALIKO) &&
|
|
!docType.getId().equals(Const.gDTS_ALIMA) && !docType.getId().equals(Const.gDTS_ALIAK) &&
|
|
!docType.getId().equals(Const.gDTS_AEINK) && !docType.getId().equals(Const.gDTS_DEINK) && !user.isMemberOfGroup( Const.gTECHNICAL_GROUP ) ) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT011049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT011001)
|
|
}
|
|
d3.log.error( "Bitte geben Sie mindestens den Lieferantennamen ein oder wählen Sie ihn aus der Drop Down Liste." )
|
|
return -170
|
|
}
|
|
|
|
// Überprüfung doppelter Einträge von Lieferanten
|
|
if( docType.getId().equals(Const.gDTS_ALIKO) ) {
|
|
lReturn = Functions.checkDuplikateLieferant( d3, doc, entryPoint.toLowerCase(), userName, doc.id() )
|
|
if( lReturn.equals("OK") ) {
|
|
// Do nothing call d3.log.error( "Die neue Lieferantenkontaktakte kann abgelegt werden!" )
|
|
} else {
|
|
// if( lReturn == "Fehler" )
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT017049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT017001)
|
|
}
|
|
d3.log.error( "Dieser Lieferant existiert bereits in dieser Opportunity, bzw. in diesem Projekt. Bitte nutzen Sie die existierende Akte." )
|
|
return -170
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* @author
|
|
* @see SearchEntry
|
|
* @return
|
|
*/
|
|
public static void splitLieferantSearch(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitLieferantSearch");
|
|
|
|
String[] splittedString
|
|
def lReturn
|
|
if( doc.field[Const.gDDF_LNAME] != null ) {
|
|
splittedString = doc.field[Const.gDDF_LNAME].split("\\|")
|
|
lReturn = splittedString.size()
|
|
} else {
|
|
splittedString = doc.field[Const.gDDF_LNR].split("\\|")
|
|
lReturn = splittedString.size()
|
|
}
|
|
|
|
if ( lReturn > 1 ) {
|
|
if( !splittedString[0].equals("d3") && !docType.getId().equals(Const.gDTS_ALIKO) && !docType.getId().equals(Const.gDTS_DLIKO) ) {
|
|
doc.field[Const.gDDF_LNR] = splittedString[0]
|
|
doc.field[Const.gDDF_LNAME] = ""
|
|
} else if( splittedString[0].equals("d3") && !docType.getId().equals(Const.gDTS_ALIKO) && !docType.getId().equals(Const.gDTS_DLIKO) ) {
|
|
doc.field[Const.gDDF_LNR] = ""
|
|
if( !docType.getId().equals(Const.gDTS_AEINK) ) {
|
|
doc.field[Const.gDDF_LNAME] = splittedString[1]
|
|
}
|
|
} else {
|
|
doc.field[Const.gDDF_LNAME] = splittedString[1]
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @author
|
|
* @see SearchEntry
|
|
* @return
|
|
*/
|
|
public static void splitActivity(D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions splitActivity");
|
|
|
|
String[] splittedString = doc.field[Const.gDDF_AKTIVITAETSID].split("\\|");
|
|
if( splittedString != null && splittedString.size() == 2 ) {
|
|
doc.field[Const.gDDF_AKTIVITAETSID] = splittedString[0]
|
|
doc.field[Const.gDDF_BESCHREIBUNG] = splittedString[1]
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Splitten aller relevanten Eigenschaften für die Dokumentart Dossier, sowie Ermittlung passender Werte anhand der Haupt- und Teilvorgangsakten
|
|
* @author Unterstützende Prozesse
|
|
* @see NewVersionEntry, InsertEntry
|
|
* @return
|
|
*/
|
|
public static void splitDossierValue(D3Interface d3, Document doc, DocumentType docType, String entryPoint) {
|
|
d3.log.info("Start Functions splitDossierValue ${docType.getId()} ${entryPoint} ");
|
|
|
|
|
|
// InsertEntry -> Dossier
|
|
// SearchEntry -> Dossier, Hauptvorgangsakte und Teilvorgangsakte
|
|
// UpdateEntry -> Dossier
|
|
// NewVersionEntry -> Dossier
|
|
|
|
// 09.08.2021 imue: Problem bei Dossier bei Änderung durch Benutzer, die eine hookseitige Änderung von nicht modifizierbaren Feldern hervor ruft
|
|
if(entryPoint != null && docType.getId().equals(Const.gDTS_DOSSI) && (entryPoint.equals("UPDATEENTRY") || entryPoint.equals("NEWVERSIONENTRY") || entryPoint.equals("UPDATEEXIT") || entryPoint.equals("NEWVERSIONEXIT"))) {
|
|
|
|
if(entryPoint.equals("UPDATEENTRY") || entryPoint.equals("NEWVERSIONENTRY")) {
|
|
// Hier dürfen im Benuzterkontext nur die NICHT modifizierbaren Felder gefüllt werden
|
|
if( doc.field[Const.gDDF_HAUPTVONR] != null && !doc.field[Const.gDDF_HAUPTVONR].equals("") ) {
|
|
String[] splittedString = doc.field[Const.gDDF_HAUPTVONR].split("\\|")
|
|
if (splittedString != null && splittedString.size() == 2) {
|
|
doc.field[Const.gDDF_HAUPTVONR] = splittedString[1].trim()
|
|
}
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_TEILVONR] != null && !doc.field[Const.gDDF_TEILVONR].equals("")) {
|
|
String[] splittedString = doc.field[Const.gDDF_TEILVONR].split("\\|")
|
|
if(splittedString != null && splittedString.size() == 2) {
|
|
doc.field[Const.gDDF_TEILVONR] = splittedString[1].trim()
|
|
}
|
|
}
|
|
|
|
} else if(entryPoint.equals("UPDATEEXIT") || entryPoint.equals("NEWVERSIONEXIT")) {
|
|
|
|
// Modifizierbare Felder im Kontext von d3groovys
|
|
Document docNew = d3.archive.getDocument(doc.id());
|
|
if( (doc.field[Const.gDDF_HAUPTVONR] != null && !doc.field[Const.gDDF_HAUPTVONR].equals("")) || (doc.field[Const.gDDF_TEILVONR] != null && !doc.field[Const.gDDF_TEILVONR].equals("")) ) {
|
|
def lHauptVoBez
|
|
def lTeilVoBez
|
|
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_HAUPTVOBEZ} as lHauptVoBez " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AHAUP}' and dok_dat_feld_${Const.gDDF_HAUPTVONR} = '${doc.field[Const.gDDF_HAUPTVONR]}' "
|
|
|
|
def sqlStatementSec = "SELECT dok_dat_feld_${Const.gDDF_TEILVOBEZ} as lTeilVoBez " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ATEIL}' and dok_dat_feld_${Const.gDDF_TEILVONR} = '${doc.field[Const.gDDF_TEILVONR]}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
List<GroovyRowResult> sqlResultSec = d3.sql.executeAndGet(sqlStatementSec)
|
|
if(sqlResult != null && sqlResult.size() > 0) {
|
|
docNew.field[Const.gDDF_HAUPTVOBEZ] = sqlResult.getAt(0).get("lHauptVoBez")
|
|
}
|
|
if(sqlResultSec != null && sqlResultSec.size() > 0) {
|
|
docNew.field[Const.gDDF_TEILVOBEZ] = sqlResultSec.getAt(0).get("lTeilVoBez")
|
|
}
|
|
}
|
|
|
|
Document docTemp;
|
|
if( doc.field[Const.gDDF_HAUPTVONR] != null && !doc.field[Const.gDDF_HAUPTVONR].equals("") ) {
|
|
try {
|
|
docTemp = d3.archive.getDocument(doc.field[Const.gDDF_HAUPTVONR]);
|
|
} catch(Exception e) {
|
|
d3.log.error(" splitDossierValue - Dokument konnte anhand ${doc.field[Const.gDDF_HAUPTVONR]} nicht ermittelt werden");
|
|
}
|
|
}
|
|
|
|
if(docTemp != null) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
try {
|
|
docNew.field[Const.gDDF_D3USER67][i] = docTemp.field[Const.gDDF_D3USER67][i];
|
|
docNew.field[Const.gDDF_ORGEINHEITEN][i] = docTemp.field[Const.gDDF_ORGEINHEITEN][i];
|
|
} catch(Exception e) {
|
|
d3.log.error(" splitDossierValue Fehler mit 60er Feld = " + e);
|
|
}
|
|
}
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_HAUPTVONR] != null && !doc.field[Const.gDDF_HAUPTVONR].equals("") ) {
|
|
def lCaseOwner
|
|
def lCnt
|
|
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_VOROWNER} as lCaseOwner FROM firmen_spezifisch WHERE doku_id = '${doc.field[Const.gDDF_HAUPTVONR]}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if(sqlResult != null) {
|
|
if(sqlResult.size() == 1) {
|
|
docNew.field[Const.gDDF_VOROWNER] = sqlResult.getAt(0).get("lCaseOwner")
|
|
} else {
|
|
docNew.field[Const.gDDF_VOROWNER] = ""
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
docNew.updateAttributes("d3groovy", true)
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, docNew.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error( "Eigenschaften für Dokument ${docNew.id()} splitDossier konnten NICHT erfolgreich aktualisiert werden!" )
|
|
}
|
|
}
|
|
} else {
|
|
|
|
if( doc.field[Const.gDDF_HAUPTVONR] != null && !doc.field[Const.gDDF_HAUPTVONR].equals("") ) {
|
|
String[] splittedString = doc.field[Const.gDDF_HAUPTVONR].split("\\|")
|
|
if (splittedString != null && splittedString.size() == 2) {
|
|
doc.field[Const.gDDF_HAUPTVOBEZ] = splittedString[0].trim()
|
|
doc.field[Const.gDDF_HAUPTVONR] = splittedString[1].trim()
|
|
}
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_TEILVONR] != null && !doc.field[Const.gDDF_TEILVONR].equals("")) {
|
|
String[] splittedString = doc.field[Const.gDDF_TEILVONR].split("\\|")
|
|
if(splittedString != null && splittedString.size() == 2) {
|
|
doc.field[Const.gDDF_TEILVOBEZ] = splittedString[0].trim()
|
|
doc.field[Const.gDDF_TEILVONR] = splittedString[1].trim()
|
|
}
|
|
}
|
|
|
|
if( (doc.field[Const.gDDF_HAUPTVONR] != null && !doc.field[Const.gDDF_HAUPTVONR].equals("")) || (doc.field[Const.gDDF_TEILVONR] != null && !doc.field[Const.gDDF_TEILVONR].equals("")) ) {
|
|
def lHauptVoBez
|
|
def lTeilVoBez
|
|
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_HAUPTVOBEZ} as lHauptVoBez " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AHAUP}' and dok_dat_feld_${Const.gDDF_HAUPTVONR} = '${doc.field[Const.gDDF_HAUPTVONR]}' "
|
|
|
|
def sqlStatementSec = "SELECT dok_dat_feld_${Const.gDDF_TEILVOBEZ} as lTeilVoBez " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ATEIL}' and dok_dat_feld_${Const.gDDF_TEILVONR} = '${doc.field[Const.gDDF_TEILVONR]}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
List<GroovyRowResult> sqlResultSec = d3.sql.executeAndGet(sqlStatementSec)
|
|
if(sqlResult != null && sqlResult.size() > 0) {
|
|
doc.field[Const.gDDF_HAUPTVOBEZ] = sqlResult.getAt(0).get("lHauptVoBez")
|
|
}
|
|
if(sqlResultSec != null && sqlResultSec.size() > 0) {
|
|
doc.field[Const.gDDF_TEILVOBEZ] = sqlResultSec.getAt(0).get("lTeilVoBez")
|
|
}
|
|
}
|
|
|
|
Document docTemp;
|
|
if( doc.field[Const.gDDF_HAUPTVONR] != null && !doc.field[Const.gDDF_HAUPTVONR].equals("") ) {
|
|
try {
|
|
docTemp = d3.archive.getDocument(doc.field[Const.gDDF_HAUPTVONR]);
|
|
} catch(Exception e) {
|
|
d3.log.error(" splitDossierValue - Dokument konnte anhand ${doc.field[Const.gDDF_HAUPTVONR]} nicht ermittelt werden");
|
|
}
|
|
}
|
|
|
|
if(docTemp != null) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
try {
|
|
doc.field[Const.gDDF_D3USER67][i] = docTemp.field[Const.gDDF_D3USER67][i];
|
|
doc.field[Const.gDDF_ORGEINHEITEN][i] = docTemp.field[Const.gDDF_ORGEINHEITEN][i];
|
|
} catch(Exception e) {
|
|
d3.log.error(" splitDossierValue Fehler mit 60er Feld = " + e);
|
|
}
|
|
}
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_HAUPTVONR] != null && !doc.field[Const.gDDF_HAUPTVONR].equals("") ) {
|
|
def lCaseOwner
|
|
def lCnt
|
|
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_VOROWNER} as lCaseOwner FROM firmen_spezifisch WHERE doku_id = '${doc.field[Const.gDDF_HAUPTVONR]}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if(sqlResult != null) {
|
|
if(sqlResult.size() == 1) {
|
|
doc.field[Const.gDDF_VOROWNER] = sqlResult.getAt(0).get("lCaseOwner")
|
|
} else {
|
|
doc.field[Const.gDDF_VOROWNER] = ""
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see
|
|
* @return
|
|
*/
|
|
public static int splitOpportunityMehrf(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitOpportunityMehrf");
|
|
|
|
def lRetCode
|
|
// Ermittlung in welchen Dokumentarten die Eigenschaft Opportunity-Nummern (Mehrfachfeld) vorkommt
|
|
def sqlStatementOppM = "SELECT DISTINCT kue_dokuart as dokuArt " +
|
|
"FROM fispe_titel_dokuart " +
|
|
"WHERE repository_id = '${SystemSpecificConst.gWeitOpportunityID}' " +
|
|
"OR repository_id = '${SystemSpecificConst.gWeitProjektnummerID}' "
|
|
List<GroovyRowResult> sqlResultOppM = d3.sql.executeAndGet(sqlStatementOppM);
|
|
List<String> dokuartenOppM = new ArrayList<>()
|
|
if(sqlResultOppM != null) {
|
|
for(GroovyRowResult grr : sqlResultOppM) {
|
|
dokuartenOppM.add(grr.get("dokuArt"))
|
|
}
|
|
}
|
|
//Splitten des zusammengesetzten String Opportunity-Nummern (Mehrfachfeld Opportunitydokumente) und Submission nach Opportunitynummer
|
|
if( dokuartenOppM.contains(docType.getId()) ) {
|
|
def lOPPInput
|
|
def lPROJInput
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if( doc.field[Const.gDDF_OPPNRM][i] != null && !doc.field[Const.gDDF_OPPNRM][i].equals("") ) {
|
|
lOPPInput = 1
|
|
break;
|
|
}
|
|
}
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if( doc.field[Const.gDDF_WEITAUFTRAGSNR][i] != null && !doc.field[Const.gDDF_WEITAUFTRAGSNR][i].equals("") ) {
|
|
lPROJInput = 1
|
|
break;
|
|
}
|
|
}
|
|
if( !docType.getId().equals(Const.gDTS_DMEOP) ) {
|
|
if( (lPROJInput == 1 && lOPPInput == 1) || (lOPPInput == 1 && doc.field[Const.gDDF_AUFTRNR] != null) || (lPROJInput == 1 && doc.field[Const.gDDF_OPPNUMMER] != null) || (doc.field[Const.gDDF_AUFTRNR] != null && doc.field[Const.gDDF_OPPNUMMER] != null ) ) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT013049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT013001)
|
|
}
|
|
d3.log.error( "Sie versuchen ein Dokument zu importieren. Dabei haben Sie sowohl eine Projekt- als auch eine Opportunitynummer (ggf. unter weitere) eingetragen. Bitte korrigieren Sie Ihre Eingabe." )
|
|
return -170
|
|
}
|
|
}
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if( doc.field[Const.gDDF_OPPNRM][i] != null && doc.field[Const.gDDF_AUFTRNR] == null) {
|
|
String[] splittedString = doc.field[Const.gDDF_OPPNRM][i].split(" \\| ")
|
|
lRetCode = splittedString.size()
|
|
//Wenn Opportunitynummer ermittelt wurde, dann Vertragsnummer in Attributfeld schreiben
|
|
if (splittedString[0] != null) {
|
|
doc.field[Const.gDDF_OPPNRM][i] = splittedString[0]
|
|
}
|
|
} else if ( doc.field[Const.gDDF_WEITAUFTRAGSNR][i] != null && doc.field[Const.gDDF_OPPNUMMER] == null ) {
|
|
String[] splittedString = doc.field[Const.gDDF_WEITAUFTRAGSNR][i].split("\\|")
|
|
lRetCode = splittedString.size()
|
|
//Wenn Opportunitynummer ermittelt wurde, dann Vertragsnummer in Attributfeld schreiben
|
|
if( splittedString[0] != null ) {
|
|
doc.field[Const.gDDF_WEITAUFTRAGSNR][i] = splittedString[0]
|
|
}
|
|
}
|
|
}
|
|
lOPPInput = 0
|
|
lPROJInput = 0
|
|
}
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see SearchEntry
|
|
* @return
|
|
*/
|
|
public static void splitOpportunitySubmission(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitOpportunitySubmission");
|
|
|
|
// Ermittlung in welchen Dokumentarten die Eigenschaft Opportunitynummer, Hauptopportunity, Submission vorkommt
|
|
def sqlStatementOpp = "SELECT DISTINCT kue_dokuart as dokuArt " +
|
|
"FROM fispe_titel_dokuart " +
|
|
"WHERE repository_id = '${SystemSpecificConst.gOpportunityNrID}' " +
|
|
" OR repository_id = '${SystemSpecificConst.gHauptOpportunityID}' "
|
|
List<GroovyRowResult> sqlResultOpp = d3.sql.executeAndGet(sqlStatementOpp);
|
|
List<String> dokuartenOpp = new ArrayList<>()
|
|
if(sqlResultOpp != null) {
|
|
for(GroovyRowResult grr : sqlResultOpp) {
|
|
dokuartenOpp.add(grr.get("dokuArt"))
|
|
}
|
|
}
|
|
//Splitten der zusammengesetzten Strings Opportunitynummer, Hauptopportunity und jeweils Submission nach Opportunitynummer
|
|
if( dokuartenOpp.contains(docType.getId()) ) {
|
|
if( doc.field[Const.gDDF_OPPNUMMER] != null ) {
|
|
String[] splittedStringOpp = doc.field[Const.gDDF_OPPNUMMER].split(" \\| ")
|
|
def lRetCodeOpp = splittedStringOpp.size()
|
|
//Wenn Vertragsnummer ermittelt wurde, dann Vertragsnummer in Attributfeld schreiben
|
|
if( splittedStringOpp[0] != null && !splittedStringOpp[0].equals("") ) {
|
|
doc.field[Const.gDDF_OPPNUMMER] = splittedStringOpp[0]
|
|
}
|
|
}
|
|
if( doc.field[Const.gDDF_HAUPTOPP] != null ) {
|
|
String[] splittedStringHOpp = doc.field[Const.gDDF_HAUPTOPP].split(" \\| ")
|
|
def lRetCodeHOpp = splittedStringHOpp.size()
|
|
//Wenn Vertragsnummer ermittelt wurde, dann Vertragsnummer in Attributfeld schreiben
|
|
if( splittedStringHOpp[0] != null && !splittedStringHOpp[0].equals("") ) {
|
|
doc.field[Const.gDDF_HAUPTOPP] = splittedStringHOpp[0]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see InsertEntry, SearchEntry
|
|
* @return keine Rückgabe; im Hintergrund wird die Projektnummer und ggf. Projektleiter und Vertreter gesetzt
|
|
*/
|
|
public static int splitProjekt(D3Interface d3, Document doc, DocumentType docType, User user, String entrypoint) {
|
|
d3.log.info("Start Functions splitProjekt");
|
|
|
|
if( doc.field[Const.gDDF_PROJNR] != null && !doc.field[Const.gDDF_PROJNR].equals("") && doc.field[Const.gDDF_PROJNR].length() >= 14 ) {
|
|
def h_projnr = doc.field[Const.gDDF_PROJNR].substring(0,14)
|
|
doc.field[Const.gDDF_PROJNR] = h_projnr
|
|
}
|
|
|
|
if(!entrypoint.equals("SEARCH")) {
|
|
def lProjLeiterDok = doc.field[Const.gDDF_PROJLEITER]
|
|
if( docType.getId().equals(Const.gDTS_DPROO) && lProjLeiterDok == null ) {
|
|
List<String> lProjBet = new ArrayList<>()
|
|
def lProjBetCount
|
|
def lRealNameUser = user.getRealName()
|
|
def lProjLeiterDokVertr = doc.field[Const.gDDF_ORGPROJVERT]
|
|
def lProjNo = doc.field[Const.gDDF_PROJNR]
|
|
// TODO Prüfung notwendig
|
|
def lUserFull = lRealNameUser + " (" + user.id() + ")"
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_PROJLEITER} as lProjLeiterProj, dok_dat_feld_${Const.gDDF_ORGPROJVERT} as lProjLeiterProjVertr " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_PROJNR} = '${lProjNo}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_APROJ}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null) {
|
|
def lProjLeiterProj = sqlResult.getAt(0).get("lProjLeiterProj")
|
|
def lProjLeiterProjVertr = sqlResult.getAt(0).get("lProjLeiterProjVertr")
|
|
if( lProjLeiterProj.equals(lUserFull) ) {
|
|
doc.field[Const.gDDF_PROJLEITER] = lProjLeiterProj
|
|
} else if ( lProjLeiterProjVertr.equals(lUserFull) ) {
|
|
doc.field[Const.gDDF_ORGPROJVERT] = lProjLeiterProjVertr
|
|
} else {
|
|
// 31.07.2017 Fehlergefahr: Anwender wählt zuerst Projekt mit 10 Berechtigten und dann nur mit 5, bleiben überz. Zeilen bestehen?
|
|
def sqlStatementProjBet = "SELECT mv.value_char as lProjBet " +
|
|
"FROM firmen_spezifisch fs " +
|
|
"LEFT JOIN firm_spez_mult_val mv ON fs.doku_id = mv.doku_id " +
|
|
"WHERE fs.dok_dat_feld_${Const.gDDF_PROJNR} = '${lProjNo}' " +
|
|
"AND mv.field_no = '${Const.gDDF_PROJBER}' " +
|
|
"AND fs.kue_dokuart = '${Const.gDTS_APROJ}' "
|
|
List<GroovyRowResult> sqlResultProjBet = d3.sql.executeAndGet(sqlStatementProjBet);
|
|
lProjBetCount = sqlResultProjBet.size()
|
|
for( GroovyRowResult grr : sqlResultProjBet) {
|
|
lProjBet.add(grr.get("lProjBet"))
|
|
}
|
|
for(int i=0; i < lProjBetCount; i++) {
|
|
if ( lProjBet.get(i).equals(lUserFull) ) {
|
|
doc.field[Const.gDDF_PROJBER][i] = lUserFull
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see SearchEntry
|
|
* @return
|
|
*/
|
|
public static void splitProjektnummer(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitProjektnummer");
|
|
|
|
// Ermittlung in welchen Dokumentarten die Eigenschaft Projektnummer vorkommt
|
|
def sqlStatementProj = "SELECT DISTINCT kue_dokuart as dokuArt " +
|
|
"FROM fispe_titel_dokuart " +
|
|
"WHERE repository_id = '${SystemSpecificConst.gProjektNrID}' "
|
|
List<GroovyRowResult> sqlResultProj = d3.sql.executeAndGet(sqlStatementProj);
|
|
List<String> dokuartenProj = new ArrayList<>()
|
|
if(sqlResultProj != null) {
|
|
for(GroovyRowResult grr : sqlResultProj) {
|
|
dokuartenProj.add(grr.get("dokuArt"))
|
|
}
|
|
}
|
|
//Splitten der zusammengesetzten Strings Projektnummer und Submission nach Projektnummer
|
|
if( dokuartenProj.contains(docType.getId()) ) {
|
|
if( doc.field[Const.gDDF_AUFTRNR] != null ) {
|
|
String[] splittedString = doc.field[Const.gDDF_AUFTRNR].split("\\|")
|
|
//Wenn Vertragsnummer ermittelt wurde, dann Vertragsnummer in Attributfeld schreiben
|
|
if( splittedString != null && splittedString[0] != null && !splittedString[0].equals("") ) {
|
|
doc.field[Const.gDDF_AUFTRNR] = splittedString[0]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Splittet den zusammengesetzten Wert der Belegnummer
|
|
* @author Service
|
|
* @see SearchEntry, UpdateEntry, NewVersionEntry, InsertEntry
|
|
* @return keine Rückgabe; im Hintergrund wird die Belegnummer gesetzt
|
|
*/
|
|
public static void splitServBelegnummer(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitServBelegnummer");
|
|
|
|
if( docType.getId().equals(Const.gDTS_DSEBE) || docType.getId().equals(Const.gDTS_ASEBE) || docType.getId().equals(Const.gDTS_DSER1 ) && doc.field[Const.gDDF_BELEGNUMMER] != null ) {
|
|
if(doc.field[Const.gDDF_BELEGNUMMER] != null) {
|
|
String[] splittedString = doc.field[Const.gDDF_BELEGNUMMER].split("\\s+");
|
|
if( splittedString != null && splittedString[0] != null && !splittedString[0].equals("") ) {
|
|
doc.field[Const.gDDF_BELEGNUMMER] = splittedString[0];
|
|
}
|
|
}
|
|
|
|
// 13.07.2020 Ergänzung um weitere BelegNummer
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitereBelegNrID) ) {
|
|
for(int i = 1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if(doc.field[Const.gDDF_WEITEREBELEGNR][i] != null) {
|
|
String[] splittedString = doc.field[Const.gDDF_WEITEREBELEGNR][i].split("\\s+");
|
|
if( splittedString != null && splittedString[0] != null && !splittedString[0].equals("") ) {
|
|
doc.field[Const.gDDF_WEITEREBELEGNR][i] = splittedString[0];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Splittet den zusammengesetzten Wert der SR_ID
|
|
* @author Service
|
|
* @see SearchEntry, UpdateEntry, NewVersionEntry, InsertEntry
|
|
* @return keine Rückgabe; im Hintergrund wird die SR_ID gefüllt
|
|
*/
|
|
public static void splitServSrId(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitServSrId");
|
|
|
|
// 12.04.2021: Ergänzung für Globale Suche
|
|
if(docType.getId().equals(Const.gDTS_DUMMY) && doc.field[Const.gDDF_SRID] != null) {
|
|
String[] splittedString = doc.field[Const.gDDF_SRID].split(" \\| ");
|
|
if( splittedString != null && splittedString.size() > 0 ) {
|
|
doc.field[Const.gDDF_SRID] = splittedString[0].trim();
|
|
}
|
|
}
|
|
|
|
// phoer 20191024: Splitten der zusammengesetzten Strings SR-ID, Beschreibung
|
|
// calb 20251204: Anpassen der Validierung
|
|
if( ( docType.getId().equals(Const.gDTS_DSERE) || docType.getId().equals(Const.gDTS_ASERE) || docType.getId().equals(Const.gDTS_DSER1) ) && doc.field[Const.gDDF_SRID] != null ) {
|
|
String[] splittedString;
|
|
if( doc.field[Const.gDDF_SRID] != null ) {
|
|
splittedString = doc.field[Const.gDDF_SRID].split(" \\| ");
|
|
if(splittedString != null) {
|
|
def lRetCodeSR = splittedString.size();
|
|
d3.log.error( "splitServSrId " + lRetCodeSR )
|
|
if( lRetCodeSR > 1 ) {
|
|
doc.field[Const.gDDF_SRID] = splittedString[0].trim();
|
|
doc.field[Const.gDDF_SVBESCHREIBUNG] = splittedString[1].trim();
|
|
}
|
|
else
|
|
{
|
|
// split() liefert nur ein Element => (nur) die ID ist gegeben
|
|
String dummyvalue = splittedString[0].trim();
|
|
def sql = "select dok_dat_feld_${Const.gDDF_SVBESCHREIBUNG} as val FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_ASERE}' AND dok_dat_feld_${Const.gDDF_SRID} = '${dummyvalue}'";
|
|
def resultset = d3.sql.executeAndGet(sql);
|
|
if ( resultset.size() > 0 )
|
|
{
|
|
doc.field[Const.gDDF_SVBESCHREIBUNG] = resultset[ 0 ]["val"];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 19.02.2020 imue - auch hier gibt es die SRID
|
|
if( ( docType.getId().equals(Const.gDTS_DSEBE) || docType.getId().equals(Const.gDTS_ASEBE) || docType.getId().equals(Const.gDTS_DSER1) ) && doc.field[Const.gDDF_SRID] != null ) {
|
|
String[] splittedString = doc.field[Const.gDDF_SRID].split(" \\| ");
|
|
if( splittedString != null && splittedString.size() > 0 ) {
|
|
doc.field[Const.gDDF_SRID] = splittedString[0].trim();
|
|
}
|
|
}
|
|
|
|
// 13.07.2020 Ergänzung um weitere BelegNummer
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitereSRIDID) ) {
|
|
for(int i = 1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if(doc.field[Const.gDDF_WEITERESRID][i] != null) {
|
|
String[] splittedString = doc.field[Const.gDDF_WEITERESRID][i].split("\\|");
|
|
if( splittedString != null && splittedString[0] != null && !splittedString[0].equals("") ) {
|
|
doc.field[Const.gDDF_WEITERESRID][i] = splittedString[0].trim();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Splitten des zusammengesetzten Strings PSP Element und Validierung
|
|
* @author
|
|
* @see
|
|
* @return
|
|
*/
|
|
public static String splitFunction( D3Interface d3, Document doc, def lDocTypeShort ) {
|
|
d3.log.info("Start Functions splitFunction");
|
|
|
|
if(doc.field[Const.gDDF_FUNKTION] != null) {
|
|
|
|
// Splitten des zusammengesetzten Strings PSP Element
|
|
if( doc.field[Const.gDDF_FUNKTION].toString().indexOf("|") > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_FUNKTION].split("\\|")
|
|
if( splittedString != null && splittedString.size() > 0 && !splittedString[0].equals("") ) {
|
|
doc.field[Const.gDDF_FUNKTION] = splittedString[0].trim()
|
|
}
|
|
}
|
|
|
|
d3.log.info("Validierung der Funktion")
|
|
|
|
//vars fktName = bausteinSucheFunktion() // Tabelle und SAP-Baustein für die Ermittlung der Lieferantenstammdaten
|
|
def suchstrName
|
|
def lLanguage
|
|
def lNetzplan
|
|
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
lLanguage = "DE"
|
|
} else if( d3.remote.getLanguage().equals("001") ) {
|
|
lLanguage = "EN"
|
|
} else {
|
|
lLanguage = "DE"
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_FUNKTION] != null && !doc.field[Const.gDDF_FUNKTION].equals("") ) {
|
|
suchstrName = doc.field[Const.gDDF_FUNKTION]
|
|
d3.log.info("Der Suchstring hat folgenden Wert: << ${suchstrName} >> ")
|
|
}
|
|
|
|
def lRetCode
|
|
//String aufsplitten
|
|
if(doc.field[Const.gDDF_NPN] != null) {
|
|
String[] splittedStringSec = doc.field[Const.gDDF_NPN].split("\\|")
|
|
//Wenn Vertragsnummer ermittelt wurde, dann Vertragsnummer in Attributfeld schreiben
|
|
if( splittedStringSec != null && splittedStringSec.size() > 0 ) {
|
|
if(splittedStringSec[0] != null) {
|
|
lNetzplan = splittedStringSec[0].trim()
|
|
}
|
|
} else {
|
|
lNetzplan = doc.field[Const.gDDF_NPN].trim()
|
|
}
|
|
}
|
|
|
|
URL url = new URL("https://" + SystemSpecificConst.baseOdata + "/sap/opu/odata/sap/ZCA_D3_VALUE_LISTS_SRV/NetworkFunctionRelationSet?\$filter=NetworkNo%20eq%20'${lNetzplan}'%20and%20LanguageIso639_1%20eq%20'${lLanguage}'&\$format=json");
|
|
try {
|
|
if(url != null) {
|
|
|
|
URLConnection con = url.openConnection();
|
|
|
|
String userpass = SystemSpecificConst.lUserOdata + ":" + SystemSpecificConst.lPassOdata;
|
|
String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userpass.getBytes()));
|
|
con.setRequestProperty ("Authorization", basicAuth);
|
|
|
|
InputStream is = con.getInputStream();
|
|
String responseValue = IOUtils.toString(is, "UTF-8");
|
|
is.close();
|
|
|
|
JSONObject obj = new JSONObject(responseValue);
|
|
|
|
JSONArray arr = obj.get("d").getJSONArray("results");
|
|
|
|
def Anzahl_Treffer = arr.length()
|
|
List<String> lErgebnis = new ArrayList<>();
|
|
|
|
if( Anzahl_Treffer == 0 ) {
|
|
return "FEHLER"
|
|
} else {
|
|
for (int i = 0; i < arr.length(); i++) {
|
|
JSONObject metadataObj = arr.getJSONObject(i);
|
|
|
|
String lFUNCTION = metadataObj.getString("FunctionIdNo");
|
|
String lFUNCTIONNAME = metadataObj.getString("Description");
|
|
//d3.log.error( "Funktion: " + ${lFUNCTION} + "|" + ${lFUNCTIONNAME})
|
|
|
|
lErgebnis.add(lFUNCTION)
|
|
}
|
|
for(int i = 0; i<Anzahl_Treffer; i++) {
|
|
if( lErgebnis.get(i).equals(doc.field[Const.gDDF_FUNKTION]) ) {
|
|
// d3.log.error( "Gültige Materialnummer ausgewählt" )
|
|
return "OK"
|
|
} else if( i == Anzahl_Treffer-1 ) {
|
|
return "FEHLER"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("StringSplitFunction - Verbindung zu OData nicht möglich")
|
|
return "FEHLERODATA"
|
|
}
|
|
}
|
|
return "FEHLERFUNKTION"
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see
|
|
* @return
|
|
*/
|
|
public static String splitModule( D3Interface d3, Document doc, def lDocTypeShort ) {
|
|
d3.log.info("Start Functions splitModule");
|
|
|
|
if(doc.field[Const.gDDF_MODUL] != null) {
|
|
|
|
if(doc.field[Const.gDDF_MODUL].toString().indexOf("|") > 0) {
|
|
// Splitten des zusammengesetzten Strings PSP Element
|
|
String[] splittedString = doc.field[Const.gDDF_MODUL].split("\\|")
|
|
def lReturn = splittedString.size()
|
|
if( lReturn > 0 && !splittedString[0].equals("") ) {
|
|
doc.field[Const.gDDF_MODUL] = splittedString[0].trim()
|
|
}
|
|
}
|
|
|
|
d3.log.info("Validierung des Modul")
|
|
|
|
def suchstrName
|
|
def lLanguage
|
|
def lNetzplan
|
|
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
lLanguage = "DE"
|
|
} else if( d3.remote.getLanguage().equals("001") ) {
|
|
lLanguage = "EN"
|
|
} else {
|
|
lLanguage = "DE"
|
|
}
|
|
|
|
// 11.10.2022 imue: 00267558
|
|
if(doc.field[Const.gDDF_FUNKTION] != null) {
|
|
String[] splittedStringSec = doc.field[Const.gDDF_FUNKTION].split("\\|")
|
|
def lRetCode = splittedStringSec.size()
|
|
if( lRetCode > 0 && !splittedStringSec[0].equals("") ) {
|
|
doc.field[Const.gDDF_FUNKTION] = splittedStringSec[0].trim()
|
|
}
|
|
if ( lRetCode >= 0 && doc.field[Const.gDDF_NPN] != null ) {
|
|
String[] splittedStringThird = doc.field[Const.gDDF_NPN].split("\\|")
|
|
lRetCode = splittedStringThird.size()
|
|
if( lRetCode > 0 && !splittedStringThird[0].equals("") ) {
|
|
lNetzplan = splittedStringThird[0].trim()
|
|
} else {
|
|
String netzplanTemp = doc.field[Const.gDDF_NPN]
|
|
if(netzplanTemp != null) {
|
|
lNetzplan = netzplanTemp.trim()
|
|
}
|
|
}
|
|
} else {
|
|
d3.log.error("Validate: Das Feld Funktion konnte nicht gesplittet werden! Returncode = ${lRetCode}")
|
|
}
|
|
}
|
|
if(lNetzplan != null) {
|
|
lNetzplan = lNetzplan.trim();
|
|
}
|
|
|
|
URL url = new URL("https://" + SystemSpecificConst.baseOdata + "/sap/opu/odata/sap/ZCA_D3_VALUE_LISTS_SRV/NetworkFunctionModuleRelationSet?\$filter=NetworkNo%20eq%20'${lNetzplan}'%20and%20FunctionIdNo%20eq%20'${doc.field[Const.gDDF_FUNKTION]}'%20and%20LanguageIso639_1%20eq%20'${lLanguage}'&\$format=json");
|
|
try {
|
|
if(url != null) {
|
|
URLConnection con = url.openConnection();
|
|
|
|
String userpass = SystemSpecificConst.lUserOdata + ":" + SystemSpecificConst.lPassOdata;
|
|
String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userpass.getBytes()));
|
|
con.setRequestProperty ("Authorization", basicAuth);
|
|
|
|
InputStream is = con.getInputStream();
|
|
String responseValue = IOUtils.toString(is, "UTF-8");
|
|
is.close();
|
|
|
|
JSONObject obj = new JSONObject(responseValue);
|
|
|
|
JSONArray arr = obj.get("d").getJSONArray("results");
|
|
List<String> lErgebnis = new ArrayList<>();
|
|
|
|
if( arr.length() == 0 || arr == null) {
|
|
return "FEHLER"
|
|
} else {
|
|
for (int i=0; i < arr.length(); i++) {
|
|
JSONObject metadataObj = arr.getJSONObject(i);
|
|
def lMODULE = metadataObj.getString("ModuleIdNo")
|
|
def lMODULENAME = metadataObj.getString("Description")
|
|
// d3.log.error( "Modul: " + lMODULE + "|" + lMODULENAME + "|" + doc.field[Const.gDDF_MODUL])
|
|
|
|
lErgebnis.add(lMODULE)
|
|
}
|
|
|
|
for( int i=0; i < arr.length(); i++) {
|
|
if( lErgebnis.get(i).equals(doc.field[Const.gDDF_MODUL]) ) {
|
|
// d3.log.error( "Gültige Materialnummer ausgewählt" )
|
|
return "OK"
|
|
} else if( i == arr.length()-1 ) {
|
|
return "FEHLER"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("stringSplitModule - Verbindung zu OData nicht möglich")
|
|
return "FEHLERODATA"
|
|
}
|
|
}
|
|
return "FEHLERFUNKTION"
|
|
}
|
|
|
|
/**
|
|
* Splittet den zusammengesetzten Usernamen in den Einzelwert
|
|
* @author Unterstützende Prozesse
|
|
* @see UpdateEntry, NewVersionEntry
|
|
* @return Einfacher Username
|
|
*/
|
|
public static void splitUser( D3Interface d3, Document doc ) {
|
|
d3.log.info("Start Functions splitUser");
|
|
|
|
def ld3user
|
|
for( int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++ ) {
|
|
ld3user = doc.field[Const.gDDF_D3USER67][i]
|
|
if( ld3user != null ) {
|
|
String[] splittedString = ld3user.split("\\=")
|
|
if(splittedString != null && splittedString.size() > 0) {
|
|
doc.field[Const.gDDF_D3USER67][i] = splittedString[0].trim()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Splittet den zusammengesetzten Wert Equipment
|
|
* @author Equipment
|
|
* @see SearchEntry, UpdateEntry, NewVersionEntry, InsertEntry
|
|
* @return keine Rückgabe; im Hintergrund wird Equipment gesetzt
|
|
*/
|
|
public static void splitEquipment(D3Interface d3, Document doc, DocumentType docType, String entryPoint) {
|
|
d3.log.info("Start Functions splitEquipment ${docType.id()}");
|
|
|
|
if( checkIfRepoIDExistsInDocType(d3, docType, SystemSpecificConst.gEquipmentID) == true ) {
|
|
if( doc.field[Const.gDDF_EQUIPMENT] != null ) {
|
|
String[] splittedString = doc.field[Const.gDDF_EQUIPMENT].split("\\|");
|
|
if( splittedString != null && splittedString.size() > 0 ) {
|
|
if( splittedString.size() >= 3 ) {
|
|
doc.field[Const.gDDF_EQUIPMENT] = splittedString[0].trim();
|
|
if(entryPoint != null && !entryPoint.equals("SEARCH")) {
|
|
doc.field[Const.gDDF_NPN] = splittedString[1].trim();
|
|
doc.field[Const.gDDF_SVBESCHREIBUNG] = splittedString[2].trim();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitereEquipmentID) == true ) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
String currentEquipment = doc.field[Const.gDDF_WEITEREEQUIPMENT][i];
|
|
if(currentEquipment != null) {
|
|
String[] splittedString = currentEquipment.split("\\|");
|
|
if( splittedString != null && splittedString.size() > 0 ) {
|
|
if( splittedString.size() > 0 ) {
|
|
doc.field[Const.gDDF_WEITEREEQUIPMENT][i] = splittedString[0].trim();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Splittet den zusammengesetzten Wert Equipments
|
|
* @author Service / Equipment
|
|
* @see SearchEntry, UpdateEntry, NewVersionEntry, InsertEntry
|
|
* @return keine Rückgabe; im Hintergrund wird Equipment gesetzt
|
|
*/
|
|
public static void splitEquipments(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions splitEquipments ${docType.id()}");
|
|
if( checkIfRepoIDExistsInDocType(d3, docType, SystemSpecificConst.gEquipmentsID) == true ) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if( doc.field[Const.gDDF_EQUIPMENTS][i] != null ) {
|
|
String[] splittedString = doc.field[Const.gDDF_EQUIPMENTS][i].split(" \\| ");
|
|
if( splittedString != null && splittedString.size() > 0 ) {
|
|
doc.field[Const.gDDF_EQUIPMENTS][i] = splittedString[0].trim();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Wenn ein weiteres Angebot zur Opportunity angelegt werden soll, setze alle Ergebnisdokumente des bisherigen Angebots,
|
|
* die auf Ja standen, auf Nein
|
|
* @author
|
|
* @see
|
|
* @return
|
|
*/
|
|
public static void updResultDoc( D3Interface d3, Document doc ) {
|
|
d3.log.info("Start Functions updResultDoc");
|
|
|
|
def lReturn
|
|
def lResultDoc
|
|
int childrenListSize = 0;
|
|
|
|
// String[] children = d3.call.link_get_children(doc.id(), "d3groovy") -> wenn das Dokument nicht mehr verknüpft war, dann liefert diese Funktion keine Ergebnisse
|
|
String sqlStatementChildren = "SELECT doku_id as dokId " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_DOPPD}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${doc.field[Const.gDDF_OPPNUMMER]}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_OPPANNr} = '${doc.field[Const.gDDF_OPPANNr]}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_ERGEBNISDOK} = 'Ja'";
|
|
List<GroovyRowResult> children = d3.sql.executeAndGet(sqlStatementChildren);
|
|
if(children != null) {
|
|
childrenListSize = children.size();
|
|
}
|
|
|
|
if( childrenListSize > 0 ) {
|
|
for(GroovyRowResult grrChild : children) {
|
|
|
|
//Hole dir für jedes Kind Dokument den Wert aus dem Feld Ergebnisdokument (ja,nein)
|
|
def sqlStatement = "SELECT fs.dok_dat_feld_${Const.gDDF_ERGEBNISDOK} as lResultDoc , pd.frei_o_gesperrt as lBlocked " +
|
|
"FROM firmen_spezifisch fs , phys_datei pd " +
|
|
"WHERE fs.doku_id = pd.doku_id " +
|
|
"AND fs.doku_id = '${grrChild.get("dokId")}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
lResultDoc = sqlResult.getAt(0).get("lResultDoc")
|
|
String lBlocked = sqlResult.getAt(0).get("lBlocked")
|
|
|
|
//Wenn Ergebnisdokument = Ja und Dokument nicht gesperrt
|
|
if( lResultDoc != null && lResultDoc.equals("Ja") && !lBlocked.equals("g") ) {
|
|
|
|
def docIdTemp = grrChild.get("dokId");
|
|
Document docTempUpdate = d3.archive.getDocument(docIdTemp)
|
|
if(docTempUpdate != null) {
|
|
docTempUpdate.field[Const.gDDF_ERGEBNISDOK] = "Nein"
|
|
try {
|
|
docTempUpdate.updateAttributes("d3groovy", true)
|
|
d3.log.info( "Der Status zum Ergebnisdokument für das Angebotsdokument ${grrChild.get("dokId")} wurde erfolgreich aktualisiert!" )
|
|
} catch(Exception e) {
|
|
String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, docTempUpdate.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
d3.log.error( "Der Status zum Ergebnisdokument für das Angebotsdokument ${grrChild.get("dokId")} wurde NICHT erfolgreich aktualisiert!" )
|
|
}
|
|
// in JPL waren die Parameter alle geleert, daher immer default verwenden
|
|
d3.call.document_send_to_dsearch( grrChild.get("dokId"), "", 0, "", false, "Fr", 0, "d3groovy")
|
|
}
|
|
}
|
|
}
|
|
} else{
|
|
d3.log.error( "Die verknüpften Dokumente zu Angebot ${doc.id()} konnten nicht ermittelt werden!")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prüfung ob ECR Aktivitäts_ID valide ist
|
|
* @author Maschinenprojekt
|
|
* @see Insert
|
|
* @see Update
|
|
* @see NewVersion
|
|
* @return Wenn die ID nicht valide ist, dann Abbruch und Meldung an den Benutzer, ansonsten wird die ID und/oder die Beschreibung gesetzt
|
|
*/
|
|
public static int validateActivity( D3Interface d3, Document doc, def pEntry) {
|
|
d3.log.info("Start Functions validateActivity");
|
|
|
|
def lReturnActivity
|
|
def lReturnDescription
|
|
def lInvalidData
|
|
def lECRAtivityID
|
|
def lECRDescription
|
|
def lRowCount
|
|
def lAuftragsnummer
|
|
|
|
lReturnActivity = doc.field[Const.gDDF_AUFTRNR].indexOf("|")
|
|
if( lReturnActivity > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_AUFTRNR].split("\\|")
|
|
lReturnActivity = splittedString.size()
|
|
lAuftragsnummer = splittedString[0].trim()
|
|
} else {
|
|
lAuftragsnummer = doc.field[Const.gDDF_AUFTRNR]
|
|
}
|
|
|
|
lReturnActivity = 0
|
|
|
|
if( doc.field[Const.gDDF_AKTIVITAETSID] != null && !doc.field[Const.gDDF_AKTIVITAETSID].equals("") ) {
|
|
|
|
String[] splittedString = doc.field[Const.gDDF_AKTIVITAETSID].split("\\|")
|
|
lReturnActivity = splittedString.size()
|
|
if( lReturnActivity == 2 ) {
|
|
doc.field[Const.gDDF_AKTIVITAETSID] = splittedString[0].trim()
|
|
}
|
|
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_AKTIVITAETSID} as lECRActivityID, dok_dat_feld_${Const.gDDF_BESCHREIBUNG} as lECRDescription " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lAuftragsnummer}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AMECR}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_AKTIVITAETSID} = '${doc.field[Const.gDDF_AKTIVITAETSID]}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
|
|
if( sqlResult.size() == 1 && pEntry.equals("Insert") ) {
|
|
doc.field[Const.gDDF_BESCHREIBUNG] = sqlResult.getAt(0).get("lECRDescription")
|
|
}
|
|
else if( sqlResult.size() < 1 ) {
|
|
lInvalidData = 1
|
|
}
|
|
|
|
} else {
|
|
lInvalidData = 1
|
|
}
|
|
|
|
if( lInvalidData == 1 ) {
|
|
// Meldung an den Benutzer, dass die Projektnummer gefüllt werden muss
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT002049)
|
|
}
|
|
else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT002001)
|
|
}
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* Validierung der Eingaben bei administrativen Akten
|
|
* @author Administration
|
|
* @see InsertEntry
|
|
* @return Rückgabe; im Hintergrund wird die Belegart gesetzt
|
|
*/
|
|
public static int validateAdminFolder( D3Interface d3, Document doc, String entryPoint ) {
|
|
d3.log.info("Start Functions validateAdminFolder");
|
|
|
|
// Register innerhalb administrative Folder muss immer einen Schlüssel aus administrative Translation enthalten
|
|
if(doc.getType().getId().equals(Const.gDTS_AAFOL) && doc.field[Const.gDDF_REGISTER] != null) {
|
|
String sqlSatement = """SELECT dok_dat_feld_${Const.gDFF_SCHLUESSEL}
|
|
FROM firmen_spezifisch
|
|
WHERE kue_dokuart = ?
|
|
AND dok_dat_feld_${Const.gDFF_SCHLUESSEL} = ? """;
|
|
List<Object> params = [
|
|
Const.gDTS_AZTXT,
|
|
doc.field[Const.gDDF_REGISTER]
|
|
];
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlSatement, params);
|
|
if(sqlResult != null) {
|
|
if(sqlResult.size() >= 1) {
|
|
// Eintrag erlaubt - es wurde ein Schlüssel aus den administrative Translation gewählt
|
|
return 0;
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", "Registereintrag nicht als Schlüssel in den administrative Translations hinterlegt")
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Übersetzungen innerhalb der administrative Translation müssen eindeutig sein
|
|
if(doc.getType().getId().equals(Const.gDTS_AZTXT)) {
|
|
|
|
if(doc.field[Const.gDFF_SCHLUESSEL] != null) {
|
|
|
|
String sqlStatementKey = null;
|
|
if(entryPoint != null && entryPoint.equals("INSERT")) {
|
|
sqlStatementKey = """SELECT doku_id
|
|
FROM firmen_spezifisch
|
|
WHERE kue_dokuart = ?
|
|
AND dok_dat_feld_${Const.gDFF_SCHLUESSEL} = ? """;
|
|
} else {
|
|
// Prüfung ob es den eingegebenen Key schon gibt
|
|
sqlStatementKey = """SELECT doku_id
|
|
FROM firmen_spezifisch
|
|
WHERE kue_dokuart = ?
|
|
AND dok_dat_feld_${Const.gDFF_SCHLUESSEL} = ?
|
|
AND doku_id != '${doc.id()}' """;
|
|
}
|
|
|
|
if(sqlStatementKey != null) {
|
|
List<Object> paramsKey = [
|
|
Const.gDTS_AZTXT,
|
|
doc.field[Const.gDFF_SCHLUESSEL].toString().trim()
|
|
];
|
|
List<GroovyRowResult> sqlResultKey = d3.sql.executeAndGet(sqlStatementKey, paramsKey);
|
|
|
|
if(sqlResultKey != null) {
|
|
if(sqlResultKey.size() >= 1) {
|
|
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if(doc.field[Const.gDDF_ISOCODE][i] != null && (doc.field[Const.gDDF_UEBERSETZUNG][i])) {
|
|
|
|
String sqlStatement = null;
|
|
if(entryPoint != null && entryPoint.equals("INSERT")) {
|
|
sqlStatement = """SELECT fs.doku_id
|
|
FROM firmen_spezifisch fs
|
|
LEFT JOIN firm_spez_mult_val mv1 ON fs.doku_id = mv1.doku_id
|
|
LEFT JOIN firm_spez_mult_val mv2 ON fs.doku_id = mv2.doku_id
|
|
WHERE fs.kue_dokuart = ?
|
|
AND fs.dok_dat_feld_${Const.gDFF_SCHLUESSEL} = ?
|
|
AND mv1.field_no = ?
|
|
AND mv1.value_char = ?
|
|
AND mv2.field_no = ?
|
|
AND mv2.value_char = ? """;
|
|
} else {
|
|
// Wenn ja, dann Prüfung ob die eingetragene Übersetzung mit der Übersetzung der gefundenen Akte übereinstimmt
|
|
sqlStatement = """SELECT fs.doku_id
|
|
FROM firmen_spezifisch fs
|
|
LEFT JOIN firm_spez_mult_val mv1 ON fs.doku_id = mv1.doku_id
|
|
LEFT JOIN firm_spez_mult_val mv2 ON fs.doku_id = mv2.doku_id
|
|
WHERE fs.kue_dokuart = ?
|
|
AND fs.dok_dat_feld_${Const.gDFF_SCHLUESSEL} = ?
|
|
AND mv1.field_no = ?
|
|
AND mv1.value_char = ?
|
|
AND mv2.field_no = ?
|
|
AND mv2.value_char = ?
|
|
AND fs.doku_id != '${doc.id()}' """;
|
|
}
|
|
|
|
if(sqlStatement != null) {
|
|
List<Object> params = [
|
|
Const.gDTS_AZTXT,
|
|
doc.field[Const.gDFF_SCHLUESSEL].toString().trim(),
|
|
Const.gDDF_ISOCODE,
|
|
doc.field[Const.gDDF_ISOCODE][i],
|
|
Const.gDDF_UEBERSETZUNG,
|
|
doc.field[Const.gDDF_UEBERSETZUNG][i].toString().trim()
|
|
];
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement, params);
|
|
|
|
if(sqlResult != null) {
|
|
if(sqlResult.size() >= 1) {
|
|
// Kombination gibt es schon, somit keine Wertemengeverletzung
|
|
} else {
|
|
// Kombination nicht erlaubt
|
|
d3.hook.setProperty("additional_info_text", "Dieser Schlüssel existiert bereits, jedoch mit einer anderen Übersetzung. Position = ${i} ");
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Key gibt es noch nicht
|
|
// Prüfung ob die eingetragene Übersetzung bereits vorhanden ist und es somit eventuell zur einer Logikverletzung kommt
|
|
// Achtung: Hier werden mehrere Eigenschaften administriert (AK = Akte, PA = Prozessart, PZ = Prozess, DG = Dokumengruppe)
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
|
|
if(doc.field[Const.gDDF_ISOCODE][i] != null && (doc.field[Const.gDDF_UEBERSETZUNG][i])) {
|
|
|
|
String sqlStatement = null;
|
|
if(entryPoint != null && entryPoint.equals("INSERT")) {
|
|
sqlStatement = """SELECT DISTINCT fs.doku_id
|
|
FROM firmen_spezifisch fs
|
|
LEFT JOIN firm_spez_mult_val mv1 ON fs.doku_id = mv1.doku_id
|
|
LEFT JOIN firm_spez_mult_val mv2 ON fs.doku_id = mv2.doku_id
|
|
WHERE fs.kue_dokuart = ?
|
|
AND mv1.field_no = ?
|
|
AND mv1.value_char = ?
|
|
AND mv2.field_no = ?
|
|
AND mv2.value_char = ?
|
|
AND dok_dat_feld_${Const.gDFF_SCHLUESSEL} LIKE '%' + SUBSTRING('${doc.field[Const.gDFF_SCHLUESSEL]}', 1, 2) + '%' """;
|
|
} else {
|
|
sqlStatement = """SELECT DISTINCT fs.doku_id
|
|
FROM firmen_spezifisch fs
|
|
LEFT JOIN firm_spez_mult_val mv1 ON fs.doku_id = mv1.doku_id
|
|
LEFT JOIN firm_spez_mult_val mv2 ON fs.doku_id = mv2.doku_id
|
|
WHERE fs.kue_dokuart = ?
|
|
AND mv1.field_no = ?
|
|
AND mv1.value_char = ?
|
|
AND mv2.field_no = ?
|
|
AND mv2.value_char = ?
|
|
AND dok_dat_feld_${Const.gDFF_SCHLUESSEL} LIKE '%' + SUBSTRING('${doc.field[Const.gDFF_SCHLUESSEL]}', 1, 2) + '%'
|
|
AND fs.doku_id != '${doc.id()}' """;
|
|
}
|
|
|
|
if(sqlStatement != null) {
|
|
List<Object> params = [
|
|
Const.gDTS_AZTXT,
|
|
Const.gDDF_ISOCODE,
|
|
doc.field[Const.gDDF_ISOCODE][i],
|
|
Const.gDDF_UEBERSETZUNG,
|
|
doc.field[Const.gDDF_UEBERSETZUNG][i].toString().trim()
|
|
];
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement, params);
|
|
|
|
if(sqlResult != null && sqlResult.size() >= 1) {
|
|
// Neuer Key, jedoch auf vorhadene Übersetzung nicht erlaubt
|
|
d3.hook.setProperty("additional_info_text", "Schlüssel neu, jedoch existiert die Übersetzung bereits. Position = ${i} ");
|
|
return 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Validierung der Belegart zur ausgewählte Belegnummer
|
|
* @author Service
|
|
* @see InsertEntry, UpdateEntry, NewVersionEntry
|
|
* @return keine Rückgabe; im Hintergrund wird die Belegart gesetzt
|
|
*/
|
|
public static int validateBelegart( D3Interface d3, Document doc ) {
|
|
d3.log.info("Start Functions validateBelegart");
|
|
|
|
// Service
|
|
if(checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gBelegNrID) && checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gBelegArtID)) {
|
|
if(doc.field[Const.gDDF_BELEGNUMMER] != null) {
|
|
String sqlSatement = "SELECT dok_dat_feld_${Const.gDDF_BELEGTYP} as val " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ASEBE}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${doc.field[Const.gDDF_BELEGNUMMER]}' ";
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlSatement);
|
|
if(sqlResult != null && sqlResult.size() == 1) {
|
|
String belegTypTemp = sqlResult.getAt(0).get("val");
|
|
if(belegTypTemp != null && !belegTypTemp.equals("")) {
|
|
if(doc.field[Const.gDDF_BELEGTYP] == null || !doc.field[Const.gDDF_BELEGTYP].equals(belegTypTemp) ) {
|
|
doc.field[Const.gDDF_BELEGTYP] = belegTypTemp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Einkauf
|
|
if(checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gEinkaufsBelegNrID)) {
|
|
if(doc.field[Const.gDDF_BELEGNUMMER] != null) {
|
|
String sqlSatement = """SELECT dok_dat_feld_${Const.gDDF_BELEGTYP} as val
|
|
FROM firmen_spezifisch
|
|
WHERE kue_dokuart = '${Const.gDTS_AEIBE}'
|
|
AND dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${doc.field[Const.gDDF_BELEGNUMMER]}' """;
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlSatement);
|
|
if(sqlResult != null && sqlResult.size() == 1) {
|
|
String belegTypTemp = sqlResult.getAt(0).get("val");
|
|
if(belegTypTemp != null && !belegTypTemp.equals("")) {
|
|
if(doc.field[Const.gDDF_BELEGTYP] == null || !doc.field[Const.gDDF_BELEGTYP].equals(belegTypTemp) ) {
|
|
doc.field[Const.gDDF_BELEGTYP] = belegTypTemp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see
|
|
* @return
|
|
*/
|
|
public static int validateBuchungskreis( D3Interface d3, Document doc, def pEntry ) {
|
|
d3.log.info("Start Functions validateBuchungskreis");
|
|
|
|
// 2016-11-23/dkle: Ermittlung des Buchungskreises
|
|
// Hinweis: Die Validierung des Buchungskreises sichert gleichzeitig eine korrekte Eingabe der Kundenkontaktdaten (siehe validateKuKoID) ab.
|
|
// Wenn die Kundenkontakt-ID nicht leer ist, ermittele anhand der Projekt_Nr oder Opportunity_Nr
|
|
// Prüfung ob die Kundenkontakt-ID existiert ist
|
|
def lKukoID
|
|
def lKuKoIDError
|
|
def lKuKoSQL
|
|
def lKuKoRowCount
|
|
List<String> lBuchkrDKUKO = new ArrayList<>();
|
|
|
|
lKukoID = doc.field[Const.gDDF_KONTAKTNUMMER];
|
|
if( lKukoID != null && !lKukoID.equals("") ) {
|
|
if( !doc.field[Const.gDDF_OPPNUMMER].equals("") && doc.field[Const.gDDF_OPPNUMMER] != null) {
|
|
lKuKoSQL = "AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = '" + doc.field[Const.gDDF_OPPNUMMER] + "'"
|
|
} else {
|
|
lKuKoSQL = "AND dok_dat_feld_${Const.gDDF_OPPNUMMER} IS NULL"
|
|
}
|
|
if( !doc.field[Const.gDDF_AUFTRNR].equals("") && doc.field[Const.gDDF_AUFTRNR] != null) {
|
|
lKuKoSQL = lKuKoSQL + " AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '" + doc.field[Const.gDDF_AUFTRNR] + "'"
|
|
} else {
|
|
lKuKoSQL = lKuKoSQL + " AND dok_dat_feld_${Const.gDDF_AUFTRNR} IS NULL"
|
|
}
|
|
if( !doc.field[Const.gDDF_KNR].equals("") && doc.field[Const.gDDF_KNR] != null ) {
|
|
lKuKoSQL = lKuKoSQL + " AND dok_dat_feld_${Const.gDDF_KNR} = '" + doc.field[Const.gDDF_KNR] + "'"
|
|
}
|
|
// d3.log.error( "lKuKoSQL: ${lKuKoSQL}" )
|
|
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_BUCHKREIS} as lBuchkrDKUKO " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_KONTAKTNUMMER} = '${doc.field[Const.gDDF_KONTAKTNUMMER]}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AKONT}' " + lKuKoSQL
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
lKuKoRowCount = sqlResult.size()
|
|
|
|
if( sqlResult.size() > 0 ) {
|
|
for (GroovyRowResult grr : sqlResult) {
|
|
lBuchkrDKUKO.add(grr.get("lBuchkrDKUKO"))
|
|
}
|
|
}
|
|
|
|
// d3.log.error( "lKuKoRowCount: ${lKuKoRowCount}" )
|
|
// d3.log.error( "lBuchkrDKUKO[lKuKoRowCount]: ${lBuchkrDKUKO.get(lKuKoRowCount)}" )
|
|
|
|
if( lKuKoRowCount == 1 ) {
|
|
if( lBuchkrDKUKO.get(0) != null && pEntry.equals("Insert") ) {
|
|
doc.field[Const.gDDF_BUCHKREIS] = lBuchkrDKUKO.get(0)
|
|
}
|
|
if( lBuchkrDKUKO.get(0) != null && !pEntry.equals("Insert") ) {
|
|
// try {
|
|
// doc.updateAttributes("d3groovy")
|
|
// } catch(Exception e) {
|
|
// String noticeHoldfile = "Eigenschaten konnten nicht aktualisiert werden: " + e
|
|
// int returnValue = d3.call.hold_file_send ( SystemSpecificConst.recipientHoldFile, noticeHoldfile, doc.id(), null, null, false, false, null, null, "d3groovy", 0, false, false, null, 0, false)
|
|
// }
|
|
}
|
|
} else {
|
|
return -170
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* Anhand der eindeutigen Eigenschaft in der Dokumentart wird der Buchungskreis ermittelt.
|
|
* Des Weiteren werden Intercompany und Regionalorganisation gesetzt.
|
|
* @author Maschine, Service, Equipment
|
|
* @see InsertEntry
|
|
* @return keine Rückgabe; im Hintergrund wird der Buchungskreis gesetzt
|
|
*/
|
|
public static int validateBuchungskreisInsert( D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions validateBuchungskreisInsert");
|
|
|
|
def lWhereClause
|
|
def lReturn
|
|
def lOppNR = doc.field[Const.gDDF_OPPNUMMER]
|
|
def lOrdNR = doc.field[Const.gDDF_AUFTRNR]
|
|
def lSRID = doc.field[Const.gDDF_SRID]
|
|
def lSBID = doc.field[Const.gDDF_BELEGNUMMER]
|
|
def lEquip = doc.field[Const.gDDF_EQUIPMENT]
|
|
if( lSRID != null && docType.getId().equals(Const.gDTS_DSERE) ) {
|
|
lWhereClause = "WHERE dok_dat_feld_${Const.gDDF_SRID} = '${lSRID}' AND kue_dokuart = '${Const.gDTS_ASERE}'"
|
|
} else if ( lSBID != null && docType.getId().equals(Const.gDTS_DSEBE) ) {
|
|
lWhereClause = "WHERE dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${lSBID}' AND kue_dokuart = '${Const.gDTS_ASEBE}'"
|
|
} else if ( lEquip != null && docType.getId().equals(Const.gDTS_DEQUI) ) {
|
|
lWhereClause = "WHERE dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${lEquip}' AND kue_dokuart = '${Const.gDTS_AEQUI}'"
|
|
} else if ( doc.field[Const.gDDF_BELEGNUMMER] != null && docType.getId().equals(Const.gDTS_DEINK) ) {
|
|
// 17.01.2023 Ergänzung Einkauf
|
|
lWhereClause = "WHERE dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${doc.field[Const.gDDF_BELEGNUMMER]}' AND kue_dokuart = '${Const.gDTS_AEIBE}'"
|
|
} else if( lOppNR != null ) {
|
|
lWhereClause = "WHERE dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNR}' AND kue_dokuart = '${Const.gDTS_AOPPU}' "
|
|
} else if( lOrdNR != null ) {
|
|
lWhereClause = "WHERE dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lOrdNR}' AND ( kue_dokuart = '${Const.gDTS_AMPRA}' OR kue_dokuart = '${Const.gDTS_APREN}' )"
|
|
} else if( docType.getId().equals(Const.gDTS_DKUKO) ) {
|
|
def lCustActID = doc.field[Const.gDDF_KONTAKTNUMMER]
|
|
def lCustActDate = doc.field[Const.gDDF_KONTAKTDATE]
|
|
def lCustActTitle = doc.field[Const.gDDF_KDAKTNAME]
|
|
if( lCustActID != null ) {
|
|
def lCustActIDSplit
|
|
String[] splittedString = lCustActID.split("\\|")
|
|
if(splittedString != null) {
|
|
lReturn = splittedString.size()
|
|
if( lReturn == 1 ) {
|
|
lCustActIDSplit = splittedString[0]
|
|
} else {
|
|
lCustActIDSplit = splittedString[1]
|
|
}
|
|
lWhereClause = "WHERE dok_dat_feld_${Const.gDDF_KONTAKTNUMMER} = '${lCustActIDSplit}' AND kue_dokuart = '${Const.gDTS_AKONT}' "
|
|
}
|
|
} else {
|
|
lWhereClause = "WHERE kue_dokuart = '${Const.gDTS_AKONT}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KDAKTNAME} = '${lCustActTitle}' " +
|
|
"AND convert(varchar,dok_dat_feld_${Const.gDDF_KONTAKTDATE},104) = '${lCustActDate}' "
|
|
}
|
|
}
|
|
def sqlStatement = "SELECT doku_id, dok_dat_feld_${Const.gDDF_BUCHKREIS} as lBuchK " +
|
|
"FROM firmen_spezifisch " +
|
|
"${lWhereClause} "
|
|
if(lWhereClause != null) {
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null && sqlResult.size() > 0) {
|
|
if(doc.field[Const.gDDF_BUCHKREIS] == null) {
|
|
def lBuchK = sqlResult.getAt(0).get("lBuchK")
|
|
if( lBuchK != null ) {
|
|
d3.log.info("Für das Dokument wurde der Buchungskreis ${lBuchK} gefunden")
|
|
doc.field[Const.gDDF_BUCHKREIS] = lBuchK
|
|
} else {
|
|
d3.log.error("Für den Import des Dokuments konnte kein Buchungskreis gefunden werden!")
|
|
}
|
|
}
|
|
|
|
// 22.06.2020 Ergänzung der Intercompany für Berechtigungssteuerung
|
|
// 12.08.2020 Ergänzung Regionalorganisation gemäß E-Mail vom 05.08.2020
|
|
String docIdKdKontakt = sqlResult.getAt(0).get("doku_id");
|
|
if(docIdKdKontakt != null && !docIdKdKontakt.equals("")) {
|
|
Document docKdKontakt = d3.archive.getDocument(docIdKdKontakt);
|
|
if(docKdKontakt != null) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if(docKdKontakt.field[Const.gDDF_BUCHKREIS68][i] != null && doc.field[Const.gDDF_BUCHKREIS68][i] == null) {
|
|
doc.field[Const.gDDF_BUCHKREIS68][i] = docKdKontakt.field[Const.gDDF_BUCHKREIS68][i];
|
|
}
|
|
if(docKdKontakt.field[Const.gDDF_REGIONALORG][i] != null && doc.field[Const.gDDF_REGIONALORG][i] == null) {
|
|
doc.field[Const.gDDF_REGIONALORG][i] = docKdKontakt.field[Const.gDDF_REGIONALORG][i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Prüfung ob eine Angebotsversion in die ein Angebotsdokument als Ergebnisdokument archiviert werden soll, bereits im Status angenommen oder geschlossen ist
|
|
* @author Opportunity
|
|
* @see Insert, Update, NewVersion
|
|
* @return Wenn eine Angebotsversion angenommen oder geschlossen ist, Meldung an User das kein Angebotsdokument mit Ergebnisdokument = ja archiviert werden darf
|
|
*/
|
|
public static int validateErgebnisdokumenteAngebot(D3Interface d3, Document doc, User user) {
|
|
d3.log.info("Start Functions validateErgebnisdokumenteAngebot");
|
|
|
|
|
|
def lANVersendet
|
|
def lANNewOffer
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_ANSTATUS} as lANVersendet, dok_dat_feld_${Const.gDDF_ANNEU} as lANNewOffer " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_ANNAME} = ? " +
|
|
"AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = ? " +
|
|
"AND dok_dat_feld_${Const.gDDF_OPPANNr} = ? " +
|
|
"AND kue_dokuart = '${Const.gDTS_AREGI}' ";
|
|
List<Object> params = [
|
|
doc.field[Const.gDDF_ANNAME],
|
|
doc.field[Const.gDDF_OPPNUMMER],
|
|
doc.field[Const.gDDF_OPPANNr]
|
|
];
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement, params);
|
|
if(sqlResult != null && sqlResult.size() > 0) {
|
|
lANVersendet = sqlResult.getAt(0).get("lANVersendet")
|
|
lANNewOffer = sqlResult.getAt(0).get("lANNewOffer")
|
|
|
|
// 06.03.2023 imue: Anpassungen aufgrund Änderungen Quicktag.dxp
|
|
if( (lANVersendet != null && (lANVersendet.toString().startsWith("versendet") || lANVersendet.toString().startsWith("angenommen") || lANVersendet.toString().startsWith("geschlossen"))) ||
|
|
(lANNewOffer != null && (lANNewOffer.toString().startsWith("Ja, mit Dokumenten") || lANNewOffer.toString().startsWith("Ja, ohne Dokumente"))) ) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT009049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT009001)
|
|
}
|
|
|
|
// Ausschluss vom d3_async aufgrund Stammdatenaktualisierung
|
|
if(user != null && !user.id().equals("d3_async"))
|
|
{
|
|
d3.log.error( "Eine der Angebotsakten in die Sie importieren moechten ist versendet, oder bereits angenommen. Es koennen keine weiteren Ergebnisdokumente abgelegt werden. Erstellen Sie ein neues Angebot, oder importieren Sie ein Basisdokument ohne Ergebnischarakter." )
|
|
return -170
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Prüfung ob ECR Change Order (Akte) in dem ein ECR CO Dokument archiviert werden soll, bereits im Status Genehmigung ist
|
|
* @author Maschinenprojekt
|
|
* @see Insert
|
|
* @see Update
|
|
* @see NewVersion
|
|
* @return Wenn ECR Change Order genehmigt ist, Meldung an User das kein ECR CO Dokument mit Ergebnisdokument = ja archiviert werden darf
|
|
*/
|
|
public static int validateErgebnisdokumenteECR(D3Interface d3, Document doc, User user) {
|
|
d3.log.info("Start Functions validateErgebnisdokumenteECR");
|
|
|
|
def userName = ""
|
|
if(user != null) {
|
|
userName = user.id()
|
|
}
|
|
def lOrdNo = doc.field[Const.gDDF_AUFTRNR]
|
|
def lActNo = doc.field[Const.gDDF_AKTIVITAETSID]
|
|
String[] splittedString = doc.field[Const.gDDF_AUFTRNR].split("\\|")
|
|
//Wenn Vertragsnummer ermittelt wurde, dann Vertragsnummer in Attributfeld schreiben
|
|
if( splittedString[0] != null ) {
|
|
lOrdNo = splittedString[0]
|
|
}
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_ECRSTATUS} as lECRState " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lOrdNo}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_AKTIVITAETSID} = '${lActNo}' "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
def lECRState = sqlResult.getAt(0).get("lECRState")
|
|
// E0003 = Genehmigung
|
|
if( lECRState.equals("E0003") ) {
|
|
// dkle, 11.12.2018: Ausnahme für den Import per Hostimport
|
|
if( userName.equals("hostimp") ) {
|
|
doc.field[Const.gDDF_ERGEBNISDOK] = "Nein"
|
|
doc.setText(4, "ToCopy")
|
|
} else {
|
|
// Meldung an den Benutzer, dass die Projektnummer gefüllt werden muss
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT003049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT003001)
|
|
}
|
|
d3.log.error( "Sie versuchen ein Ergebnisdokument in einen genehmigten ECR zu importieren. Bitte korrigieren Sie Ihre Eingabe." )
|
|
return -170
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
|
|
/**
|
|
* Prüfung des Kunden anhang der Kundennummer oder des Kundennamens, abhängig von der Eingabe und des Anwendungsfalls.
|
|
* @author Maschinenprojekt, Opportunity, Service, Kundenmanagement
|
|
* @see Insert
|
|
* @see Update
|
|
* @see NewVersion
|
|
* @return Wenn der Kunde nicht valide ist, dann Abbruch und Meldung an den Benutzer, das ein valider Kunde ausgewählt werden muss.
|
|
*/
|
|
public static int validateKunden(D3Interface d3, Document doc, DocumentType docType, User user, String entrypoint) {
|
|
d3.log.info("Start Functions validateKunden");
|
|
|
|
def lKDNr = doc.field[Const.gDDF_KNR]
|
|
def lKDName = doc.field[Const.gDDF_KNAME]
|
|
def lKDNrSplit
|
|
def lKDNameSplit
|
|
def lValidateKDName
|
|
def lCustomerCount
|
|
|
|
def userName = ""
|
|
if(user != null) {
|
|
userName = user.id();
|
|
}
|
|
|
|
String[] splittedString
|
|
|
|
if( doc.field[Const.gDDF_KNR] != null) {
|
|
def lReturn = doc.field[Const.gDDF_KNR].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
lKDNrSplit = 1
|
|
}
|
|
}
|
|
if( doc.field[Const.gDDF_KNAME] != null ) {
|
|
def lReturn2 = doc.field[Const.gDDF_KNAME].indexOf("|")
|
|
if( lReturn2 > 0 ) {
|
|
lKDNameSplit = 1
|
|
}
|
|
}
|
|
|
|
if( lKDNr != null && lKDName == null && lKDNrSplit == 1 ) {
|
|
splittedString = lKDNr.split("\\|")
|
|
} else if ( lKDNr == null && lKDName != null && lKDNameSplit == 1 ) {
|
|
splittedString = lKDName.split("\\|")
|
|
} else if ( lKDNr != null && lKDName != null && lKDNrSplit == 1 ) {
|
|
splittedString = lKDNr.split("\\|")
|
|
} else if( lKDNr != null && lKDName == null && lKDNrSplit != 1 ) {
|
|
def sqlStatement = "SELECT ISNULL(dok_dat_feld_${Const.gDDF_KNAME},'') as lValidateKDName " +
|
|
"FROM firmen_spezifisch as fs, phys_datei as pd " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AKUND}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KNR} = '${doc.field[Const.gDDF_KNR]}' " +
|
|
"AND pd.frei_o_gesperrt = 'f' " +
|
|
"AND pd.doku_id = fs.doku_id "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if( sqlResult != null && sqlResult.size() > 0) {
|
|
lValidateKDName = sqlResult.getAt(0).get("lValidateKDName")
|
|
lCustomerCount = sqlResult.size()
|
|
}
|
|
|
|
if( lCustomerCount != 1 ) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT020049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT020001)
|
|
}
|
|
d3.log.error( "Bitte geben Sie einen gültigen Kunden an." )
|
|
return -170
|
|
} else if( entrypoint.equals("insert")) {
|
|
doc.field[Const.gDDF_KNAME] = lValidateKDName
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
if( entrypoint.equals("update")) {
|
|
|
|
def sqlStatement = "SELECT ISNULL(dok_dat_feld_${Const.gDDF_KNAME},'') as lValidateKDName " +
|
|
"FROM firmen_spezifisch as fs, phys_datei as pd " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AKUND}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KNR} = '${doc.field[Const.gDDF_KNR]}' " +
|
|
"AND pd.frei_o_gesperrt = 'f' " +
|
|
"AND pd.doku_id = fs.doku_id "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if(sqlResult != null && sqlResult.size() > 0) {
|
|
lValidateKDName = sqlResult.getAt(0).get("lValidateKDName")
|
|
}
|
|
lCustomerCount = sqlResult.size()
|
|
|
|
} else if( entrypoint.equals("insert")) {
|
|
|
|
if( user.isMemberOfGroup( Const.gTECHNICAL_GROUP ) ) {
|
|
def tmpKdNr = doc.field[Const.gDDF_KNR]
|
|
def tmpKdName = doc.field[Const.gDDF_KNAME]
|
|
def sqlStatement = "SELECT ISNULL(dok_dat_feld_${Const.gDDF_KNAME},'') as lValidateKDName " +
|
|
"FROM firmen_spezifisch as fs, phys_datei as pd " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AKUND}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KNR} = '${doc.field[Const.gDDF_KNR]}' " +
|
|
"AND pd.frei_o_gesperrt = 'f' " +
|
|
"AND pd.doku_id = fs.doku_id "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if( sqlResult != null && sqlResult.size() > 0) {
|
|
lCustomerCount = sqlResult.size()
|
|
lValidateKDName = sqlResult.getAt(0).get("lValidateKDName")
|
|
}
|
|
} else {
|
|
|
|
if( docType.getId().equals(Const.gDTS_DKUKO) && ( doc.field[Const.gDDF_OPPNUMMER] != null || doc.field[Const.gDDF_AUFTRNR] != null ) ) {
|
|
def lProjNrTMP
|
|
def lOppNrTMP
|
|
def lAndClause = ""
|
|
// da splittedString oben global gesetzt wird, hier vorsichtshalber leeren
|
|
splittedString = null;
|
|
if ( doc.field[Const.gDDF_OPPNUMMER] != null ) {
|
|
def lReturn = doc.field[Const.gDDF_OPPNUMMER].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
splittedString = doc.field[Const.gDDF_OPPNUMMER].split("\\|")
|
|
lReturn = splittedString.size()
|
|
lOppNrTMP = splittedString[0]
|
|
lAndClause = "AND f.dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNrTMP}' "
|
|
} else {
|
|
lAndClause = "AND f.dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${doc.field[Const.gDDF_OPPNUMMER]}' "
|
|
}
|
|
}
|
|
if( doc.field[Const.gDDF_AUFTRNR] != null ) {
|
|
def lReturn = doc.field[Const.gDDF_AUFTRNR].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
splittedString = doc.field[Const.gDDF_AUFTRNR].split("\\|")
|
|
lReturn = splittedString.size()
|
|
lProjNrTMP = splittedString[0]
|
|
lAndClause = "AND f.dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lProjNrTMP}' "
|
|
} else {
|
|
lAndClause = "AND f.dok_dat_feld_${Const.gDDF_AUFTRNR} = '${doc.field[Const.gDDF_AUFTRNR]}' "
|
|
}
|
|
}
|
|
// 29.05.2020 imue Ergänzung um Kundenkontakt-Id weil ansonsten nicht eindeutig
|
|
def sqlStatement = "SELECT DISTINCT f.dok_dat_feld_${Const.gDDF_KNR} as lKdNr, f.dok_dat_feld_${Const.gDDF_KNAME} as lKdName " +
|
|
"FROM firmen_spezifisch as f, phys_datei as p " +
|
|
"WHERE f.kue_dokuart = '${Const.gDTS_AKONT}' " +
|
|
"AND p.frei_o_gesperrt = 'f' " +
|
|
"AND p.doku_id = f.doku_id " +
|
|
"AND dok_dat_feld_${Const.gDDF_KNR} = '${doc.field[Const.gDDF_KNR]}' " +
|
|
"${lAndClause} "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if( sqlResult != null && sqlResult.size() > 0) {
|
|
def pRowCount = sqlResult.size()
|
|
if( pRowCount == 1 ) {
|
|
doc.field[Const.gDDF_KNR] = sqlResult.getAt(0).get("lKdNr")
|
|
doc.field[Const.gDDF_KNAME] = sqlResult.getAt(0).get("lKdName")
|
|
} else {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT020049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT020001)
|
|
}
|
|
d3.log.error( "Bitte geben Sie einen gültigen Kunden an." )
|
|
return -170
|
|
}
|
|
}
|
|
}
|
|
|
|
// 27.07.2020 imue Validierung des Kundennames entfernt
|
|
// Es führte im Produktivsystem dazu, das wenn ein User versuchte per Drag und Drop ein Dokument auf eine Kundenaktivitätsakte abzulegen
|
|
// und der Name auf dieser Akte nicht mit der Kundenakte übereinstimmte, keine Ablage möglich war!
|
|
def sqlStatement = "SELECT ISNULL(dok_dat_feld_${Const.gDDF_KNAME},'') as lValidateKDName " +
|
|
"FROM firmen_spezifisch as fs, phys_datei as pd " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AKUND}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KNR} = '${doc.field[Const.gDDF_KNR]}' " +
|
|
"AND pd.frei_o_gesperrt = 'f' " +
|
|
"AND pd.doku_id = fs.doku_id "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if( sqlResult != null && sqlResult.size() > 0) {
|
|
lCustomerCount = sqlResult.size()
|
|
lValidateKDName = sqlResult.getAt(0).get("lValidateKDName")
|
|
}
|
|
}
|
|
}
|
|
|
|
if( lCustomerCount != 1 ) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT020049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT020001)
|
|
}
|
|
d3.log.error( "Bitte geben Sie einen gültigen Kunden an." )
|
|
return -170
|
|
}
|
|
}
|
|
|
|
if(splittedString != null) {
|
|
if( splittedString[0] != null || ( doc.field[Const.gDDF_KNR] != null && doc.field[Const.gDDF_KNAME] != null ) ) {
|
|
if( splittedString[0] != null ) {
|
|
doc.field[Const.gDDF_KNR] = splittedString[0]
|
|
}
|
|
|
|
def sqlStatement = "SELECT ISNULL(dok_dat_feld_${Const.gDDF_KNAME},'') as lValidateKDName " +
|
|
"FROM firmen_spezifisch as fs, phys_datei as pd " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AKUND}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KNR} = '${doc.field[Const.gDDF_KNR]}' " +
|
|
"AND pd.frei_o_gesperrt = 'f' " +
|
|
"AND pd.doku_id = fs.doku_id "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
if( sqlResult != null && sqlResult.size() > 0) {
|
|
lValidateKDName = sqlResult.getAt(0).get("lValidateKDName")
|
|
lCustomerCount = sqlResult.size()
|
|
}
|
|
}
|
|
}
|
|
|
|
if( lCustomerCount != 1 ) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT020049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT020001)
|
|
}
|
|
d3.log.error( "Bitte geben Sie einen gültigen Kunden an." )
|
|
return -170
|
|
}
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author Opportunity
|
|
* @see InsertEntry, NewVersionEntry, ValidateUpdateEntry, SearchEntry
|
|
* @return
|
|
*/
|
|
public static int validateKuKoID( D3Interface d3, Document doc, User user, def pEntry) {
|
|
d3.log.info("Start Functions validateKuKoID");
|
|
|
|
// 06.02.2018/dkle: Funktion für Insert, Update, New Version ausgelagert
|
|
// Unterscheidung Insert vs. Update/New Version, da nur die Erkennungsattribute änderbar sind (Kundenkontakt_ID, Kunden_Nr, Projekt_Nr, Opportunity_Nr)
|
|
// call api_log_error( "proc validateKuKoID( :(pUser), :(pEntry), :(pDocId) )" )
|
|
def lReturn
|
|
def lKuKoIDError
|
|
def lKuKoSQL
|
|
def lKuKoRowCount
|
|
def pUser = user.id();
|
|
|
|
String lCustActDate = null;
|
|
String lCustActName = null;
|
|
String lKuKoOppNr = null;
|
|
String lKuKoProjNr = null;
|
|
String lKuKoKdNr = null;
|
|
|
|
if( doc.field[Const.gDDF_OPPNUMMER] != null && !doc.field[Const.gDDF_OPPNUMMER].equals("") ) {
|
|
lReturn = doc.field[Const.gDDF_OPPNUMMER].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_OPPNUMMER].split("\\|")
|
|
lReturn = splittedString.size()
|
|
if( lReturn == 2 ) {
|
|
doc.field[Const.gDDF_OPPNUMMER] = splittedString[0].trim()
|
|
}
|
|
}
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_AUFTRNR] != null && !doc.field[Const.gDDF_AUFTRNR].equals("") ) {
|
|
lReturn = doc.field[Const.gDDF_AUFTRNR].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_AUFTRNR].split("\\|")
|
|
lReturn = splittedString.size()
|
|
if( lReturn == 2 ) {
|
|
doc.field[Const.gDDF_AUFTRNR] = splittedString[0].trim()
|
|
}
|
|
}
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_KNR] != null && !doc.field[Const.gDDF_KNR].equals("") ) {
|
|
lReturn = doc.field[Const.gDDF_KNR].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_KNR].split("\\|")
|
|
lReturn = splittedString.size()
|
|
if( lReturn == 5 ) {
|
|
doc.field[Const.gDDF_KNR] = splittedString[0].trim()
|
|
}
|
|
}
|
|
}
|
|
|
|
if( ( doc.field[Const.gDDF_KONTAKTNUMMER] != null && !doc.field[Const.gDDF_KONTAKTNUMMER].equals("")) && ( !pUser.equals("hostimp") && !user.isMemberOfGroup( Const.gTECHNICAL_GROUP ) ) ) {
|
|
|
|
// 09.05.2017 Anpassung, da sich der Aufbau geändert hat
|
|
// Aufbau: <Präfix: OP, CM, PR>|<Zuordnung (KdNr, OppNr, ProjNr)>|<KuKo-ID>|<KuKo-Termin>|<KuKo-Bezeichnung>
|
|
lReturn = doc.field[Const.gDDF_KONTAKTNUMMER].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_KONTAKTNUMMER].split("\\|")
|
|
lReturn = splittedString.size()
|
|
if( lReturn == 5 ) {
|
|
if( splittedString[0].equals("OP") ) {
|
|
if( doc.field[Const.gDDF_OPPNUMMER].equals("") || doc.field[Const.gDDF_OPPNUMMER] == null ) {
|
|
doc.field[Const.gDDF_OPPNUMMER] = splittedString[1].trim()
|
|
}
|
|
}
|
|
else if( splittedString[0].equals("PR") ) {
|
|
if( doc.field[Const.gDDF_AUFTRNR].equals("") || doc.field[Const.gDDF_AUFTRNR] == null) {
|
|
doc.field[Const.gDDF_AUFTRNR] = splittedString[1].trim()
|
|
}
|
|
}
|
|
else if( splittedString[0].equals("CM") ) {
|
|
if( doc.field[Const.gDDF_KNR].equals("") || doc.field[Const.gDDF_KNR] == null ) {
|
|
doc.field[Const.gDDF_KNR] = splittedString[1].trim()
|
|
}
|
|
}
|
|
|
|
if( pEntry.equals("Insert") ) {
|
|
doc.field[Const.gDDF_KONTAKTNUMMER] = splittedString[2].trim()
|
|
doc.field[Const.gDDF_KONTAKTDATE] = splittedString[3].trim()
|
|
doc.field[Const.gDDF_KDAKTNAME] = splittedString[4].trim()
|
|
} else {
|
|
doc.field[Const.gDDF_KONTAKTNUMMER] = splittedString[2].trim()
|
|
}
|
|
} else {
|
|
lKuKoIDError = 1
|
|
}
|
|
} else {
|
|
|
|
if( doc.field[Const.gDDF_OPPNUMMER] != null && !doc.field[Const.gDDF_OPPNUMMER].equals("") ) {
|
|
lKuKoSQL = " AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${doc.field[Const.gDDF_OPPNUMMER]}'"
|
|
} else {
|
|
lKuKoSQL = " AND dok_dat_feld_${Const.gDDF_OPPNUMMER} IS NULL"
|
|
}
|
|
if( doc.field[Const.gDDF_AUFTRNR] != null && !doc.field[Const.gDDF_AUFTRNR].equals("") ) {
|
|
lKuKoSQL = lKuKoSQL + " AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '${doc.field[Const.gDDF_AUFTRNR]}'"
|
|
} else {
|
|
lKuKoSQL = lKuKoSQL + " AND dok_dat_feld_${Const.gDDF_AUFTRNR} IS NULL"
|
|
}
|
|
if( doc.field[Const.gDDF_KNR] != null && !doc.field[Const.gDDF_KNR].equals("") ) {
|
|
lKuKoSQL = lKuKoSQL + " AND dok_dat_feld_${Const.gDDF_KNR} = '${doc.field[Const.gDDF_KNR]}'"
|
|
}
|
|
// d3.log.error( "lKuKoSQL: ${lKuKoSQL}" )
|
|
|
|
// Test, ob Validierung über Kundenkontakt_ID ein eindeutiges Ergebnis liefert
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_KONTAKTDATE} as lCustActDate, dok_dat_feld_${Const.gDDF_KDAKTNAME} as lCustActName, dok_dat_feld_${Const.gDDF_OPPNUMMER} as lKuKoOppNr, dok_dat_feld_${Const.gDDF_AUFTRNR} as lKuKoProjNr, dok_dat_feld_${Const.gDDF_KNR} as lKuKoKdNr " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_KONTAKTNUMMER} = '${doc.field[Const.gDDF_KONTAKTNUMMER]}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AKONT}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
lKuKoRowCount = sqlResult.size()
|
|
|
|
if( sqlResult.size() > 1 ) {
|
|
// Andernfalls werden alle anderen Attribute hinzu gezogen, nur eindeutige Treffer werden erfolgreich abgelegt/aktualisiert
|
|
def sqlStatementSec = "SELECT dok_dat_feld_${Const.gDDF_KONTAKTDATE} as lCustActDate, dok_dat_feld_${Const.gDDF_KDAKTNAME} as lCustActName, dok_dat_feld_${Const.gDDF_OPPNUMMER} as lKuKoOppNr, dok_dat_feld_${Const.gDDF_AUFTRNR} as lKuKoProjNr, dok_dat_feld_${Const.gDDF_KNR} as lKuKoKdNr " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${Const.gDDF_KONTAKTNUMMER} = '${doc.field[Const.gDDF_KONTAKTNUMMER]}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AKONT}' " + lKuKoSQL
|
|
|
|
sqlResult = d3.sql.executeAndGet(sqlStatementSec);
|
|
lKuKoRowCount = sqlResult.size()
|
|
}
|
|
|
|
if(sqlResult.size() > 0) {
|
|
lCustActDate = sqlResult.getAt(0).get("lCustActDate");
|
|
lCustActName = sqlResult.getAt(0).get("lCustActName");
|
|
lKuKoOppNr = sqlResult.getAt(0).get("lKuKoOppNr");
|
|
lKuKoProjNr = sqlResult.getAt(0).get("lKuKoProjNr");
|
|
lKuKoKdNr = sqlResult.getAt(0).get("lKuKoKdNr");
|
|
}
|
|
|
|
if( lKuKoRowCount > 1 || lKuKoRowCount == 0 ) {
|
|
lKuKoIDError = 1
|
|
} else if( lKuKoRowCount == 1 && pEntry.equals("Insert") ) {
|
|
if( doc.field[Const.gDDF_KONTAKTDATE].equals("") || doc.field[Const.gDDF_KONTAKTDATE] == null ) {
|
|
try {
|
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yyy-MM-dd hh:mm:ss.SSS");
|
|
Date parsedDate = dateFormat.parse(lCustActDate);
|
|
doc.field[Const.gDDF_KONTAKTDATE] = parsedDate;
|
|
} catch(Exception e) {
|
|
d3.log.error("validateKuKoID Fehler = " + e);
|
|
}
|
|
}
|
|
if( doc.field[Const.gDDF_KDAKTNAME].equals("") || doc.field[Const.gDDF_KDAKTNAME] == null ) {
|
|
doc.field[Const.gDDF_KDAKTNAME] = lCustActName
|
|
}
|
|
if( doc.field[Const.gDDF_OPPNUMMER].equals("") || doc.field[Const.gDDF_OPPNUMMER] == null ) {
|
|
doc.field[Const.gDDF_OPPNUMMER] = checkIfNullValue(lKuKoOppNr)
|
|
}
|
|
if( doc.field[Const.gDDF_AUFTRNR].equals("") || doc.field[Const.gDDF_AUFTRNR] == null ) {
|
|
doc.field[Const.gDDF_AUFTRNR] = checkIfNullValue(lKuKoProjNr)
|
|
}
|
|
if( doc.field[Const.gDDF_KNR].equals("") || doc.field[Const.gDDF_KNR] == null) {
|
|
doc.field[Const.gDDF_KNR] = lKuKoKdNr
|
|
}
|
|
} else if( lKuKoRowCount == 1 && !pEntry.equals("Insert") && !pEntry.equals("SEARCH")) {
|
|
if( doc.field[Const.gDDF_OPPNUMMER] == "" ) {
|
|
doc.field[Const.gDDF_OPPNUMMER] = checkIfNullValue(lKuKoOppNr)
|
|
}
|
|
if( doc.field[Const.gDDF_AUFTRNR].equals("") || doc.field[Const.gDDF_AUFTRNR] == null ) {
|
|
doc.field[Const.gDDF_AUFTRNR] = checkIfNullValue(lKuKoProjNr)
|
|
}
|
|
if( doc.field[Const.gDDF_KNR].equals("") || doc.field[Const.gDDF_KNR] == null) {
|
|
doc.field[Const.gDDF_KNR] = lKuKoKdNr
|
|
}
|
|
}
|
|
}
|
|
|
|
if( lKuKoIDError == 1 ) {
|
|
return -170
|
|
} else {
|
|
// Hinweis: Die Validierung des Buchungskreises sichert gleichzeitig eine korrekte Eingabe aller Daten ab.
|
|
lReturn = validateBuchungskreis( d3, doc, pEntry )
|
|
|
|
if( lReturn == -170 ) {
|
|
return -170
|
|
}
|
|
}
|
|
|
|
}
|
|
else if ( (doc.field[Const.gDDF_KONTAKTDATE] != null && !doc.field[Const.gDDF_KONTAKTDATE].equals("")) && (doc.field[Const.gDDF_KDAKTNAME] != null && !doc.field[Const.gDDF_KDAKTNAME].equals("")) && ( !pUser.equals("hostimp") && !user.isMemberOfGroup( Const.gTECHNICAL_GROUP ) ) ) {
|
|
|
|
// d3.log.error( "Validierung per Kontaktdatum und Beschreibung" )
|
|
List<String> lCustActID = new ArrayList<>();
|
|
def lCustActDateTemp = doc.field[Const.gDDF_KONTAKTDATE]
|
|
def lCustActNameTemp = doc.field[Const.gDDF_KDAKTNAME]
|
|
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_KONTAKTNUMMER} as lCustActID, dok_dat_feld_${Const.gDDF_OPPNUMMER} as lKuKoOppNr, dok_dat_feld_${Const.gDDF_AUFTRNR} as lKuKoProjNr, dok_dat_feld_${Const.gDDF_KNR} as lKuKoKdNr " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE Convert(Varchar(25), dok_dat_feld_${Const.gDDF_KONTAKTDATE}, 104) = '${lCustActDateTemp}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_KDAKTNAME} = '${lCustActNameTemp}' " +
|
|
"AND kue_dokuart = '${Const.gDTS_AKONT}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
lKuKoRowCount = sqlResult.size()
|
|
|
|
if(sqlResult.size() > 0) {
|
|
for (GroovyRowResult grr : sqlResult) {
|
|
lCustActID.add(grr.get("lCustActID"))
|
|
lKuKoOppNr.add(grr.get("lKuKoOppNr"))
|
|
lKuKoProjNr.add(grr.get("lKuKoProjNr"))
|
|
lKuKoKdNr.add(grr.get("lKuKoKdNr"))
|
|
}
|
|
}
|
|
|
|
// call api_log_error( "lKuKoRowCount Datensätze gefunden: :(lKuKoRowCount)" )
|
|
if( lKuKoRowCount == 1 ) {
|
|
if ( lCustActID != null && lCustActID.size() > 0 && pEntry.equals("Insert") ) {
|
|
doc.field[Const.gDDF_KONTAKTNUMMER] = lCustActID.get(0)
|
|
doc.field[Const.gDDF_OPPNUMMER] = lKuKoOppNr.get(0)
|
|
doc.field[Const.gDDF_AUFTRNR] = lKuKoProjNr.get(0)
|
|
doc.field[Const.gDDF_KNR] = lKuKoKdNr.get(0)
|
|
}
|
|
else if( lCustActID != null && lCustActID.size() > 0 && !pEntry.equals("Insert") ) {
|
|
doc.field[Const.gDDF_KONTAKTNUMMER] = lCustActID.get(0)
|
|
doc.field[Const.gDDF_OPPNUMMER] = lKuKoOppNr.get(0)
|
|
doc.field[Const.gDDF_AUFTRNR] = lKuKoProjNr.get(0)
|
|
doc.field[Const.gDDF_KNR] = lKuKoKdNr.get(0)
|
|
}
|
|
// Hinweis: Die Validierung des Buchungskreises sichert gleichzeitig eine korrekte Eingabe aller Daten ab.
|
|
lReturn = validateBuchungskreis( d3, doc, pEntry )
|
|
// call api_log_error( "Ende von dem IF validateBuchungskreis: :(lReturn)" )
|
|
|
|
if( lReturn == -170 ) {
|
|
return -170
|
|
}
|
|
} else {
|
|
return -170
|
|
}
|
|
}
|
|
|
|
return 0
|
|
// d3.log.error( "Ende proc validateKuKoID( ${pUser}, ${pEntry}, ${pDocId} )" )
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see InsertEntry, UpdateAttributeEntry, NewVersionEntry
|
|
* @return
|
|
*/
|
|
public static String validateLiefName( D3Interface d3, Document doc, def pEntry) {
|
|
d3.log.info("Start Functions validateLiefName = " + doc.getType().getId());
|
|
|
|
// Umbau auf d.3 Lieferanten
|
|
// Ermittlung des Lieferantennamens
|
|
// Die Ermittlung erfolgt nun generell per d.3 Akte "Lieferantenakte" (ALIEF)
|
|
// Ausnahme: Lieferantenkontaktdokument (DLIMA), hier wird die Lieferantenauswahl anhand Projekt/Opportunitynummer eingeschränkt
|
|
|
|
def lLiefSQL
|
|
def lOppNr
|
|
def lAuftrNr
|
|
def lKdNr
|
|
def lLiefAnz
|
|
def lLiefNr
|
|
def lLiefName
|
|
def lReturn
|
|
def gTMPLFNr
|
|
|
|
// 20.01.2023 imue: Ergänzung von Einkaufsbelegdokumenten
|
|
if( doc.getType().getId().equals(Const.gDTS_ALIKO) || doc.getType().getId().equals(Const.gDTS_ALONT) || doc.getType().getId().equals(Const.gDTS_DLIMA) || doc.getType().getId().equals(Const.gDTS_DEINK) ) {
|
|
// Hier alle Dokumentarten, die weder Projekt noch Opportunitynummer enthalten.
|
|
lLiefSQL = " "
|
|
} else {
|
|
// Hier alle Dokumentarten, die über de Opportunity und Projektnummer verfügen
|
|
if( doc.field[Const.gDDF_OPPNUMMER] != null ) {
|
|
|
|
lReturn = doc.field[Const.gDDF_OPPNUMMER].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_OPPNUMMER].split("\\|")
|
|
lReturn = splittedString.size()
|
|
if( lReturn == 2 ) {
|
|
lOppNr = splittedString[0].trim()
|
|
lLiefSQL = " AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNr}' "
|
|
}
|
|
} else {
|
|
lOppNr = doc.field[Const.gDDF_OPPNUMMER]
|
|
lLiefSQL = " AND dok_dat_feld_${Const.gDDF_OPPNUMMER} = '${lOppNr}' "
|
|
}
|
|
} else {
|
|
lLiefSQL = " AND dok_dat_feld_${Const.gDDF_OPPNUMMER} IS NULL "
|
|
}
|
|
|
|
if( doc.field[Const.gDDF_AUFTRNR] != null ) {
|
|
lReturn = doc.field[Const.gDDF_AUFTRNR].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_AUFTRNR].split("\\|")
|
|
lReturn = splittedString.size()
|
|
if( lReturn == 2 ) {
|
|
lAuftrNr = splittedString[0].trim()
|
|
lLiefSQL = lLiefSQL + " AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lAuftrNr}' "
|
|
}
|
|
} else {
|
|
lAuftrNr = doc.field[Const.gDDF_AUFTRNR]
|
|
lLiefSQL = lLiefSQL + " AND dok_dat_feld_${Const.gDDF_AUFTRNR} = '${lAuftrNr}' "
|
|
}
|
|
} else {
|
|
lLiefSQL = lLiefSQL + " AND dok_dat_feld_${Const.gDDF_AUFTRNR} IS NULL "
|
|
}
|
|
}
|
|
|
|
// d3.log.error( "dok_dat_feld[${Const.gDDF_LNAME}] " + ${doc.field[Const.gDDF_LNAME]} )
|
|
// d3.log.error( "dok_dat_feld[${Const.gDDF_LNR}] " + ${doc.field[Const.[gDDF_LNR]} )
|
|
// d3.log.error( "gTMPLFNr " + ${gTMPLFNr} )
|
|
|
|
// Eingabefeld Lieferantennummer freigegeben
|
|
if( (!doc.field[Const.gDDF_LNR].equals("") && doc.field[Const.gDDF_LNR] != null) && ( doc.getType().getId().equals(Const.gDTS_ALONT) || doc.getType().getId().equals(Const.gDTS_DLIMA) ) ) {
|
|
|
|
lReturn = doc.field[Const.gDDF_LNR].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_LNR].split("\\|")
|
|
lReturn = splittedString.size()
|
|
if( lReturn == 5 ) {
|
|
lLiefNr = splittedString[0].trim()
|
|
lLiefName = splittedString[1].trim()
|
|
lLiefSQL = lLiefSQL + " AND dok_dat_feld_${Const.gDDF_LNR} = '${lLiefNr}' "
|
|
lLiefSQL = lLiefSQL + " AND dok_dat_feld_${Const.gDDF_LNAME} = '${lLiefName}' "
|
|
}
|
|
} else {
|
|
lLiefNr = doc.field[Const.gDDF_LNR]
|
|
lLiefSQL = lLiefSQL + " AND dok_dat_feld_${Const.gDDF_LNR} = '${lLiefNr}' "
|
|
}
|
|
} else if( (doc.field[Const.gDDF_LNR].equals("") || doc.field[Const.gDDF_LNR] == null) && ( doc.getType().getId().equals(Const.gDTS_ALONT) || doc.getType().getId().equals(Const.gDTS_DLIMA) ) ) {
|
|
d3.log.error( "Es wurde kein Lieferantennummer eingegeben." )
|
|
return "Fehler"
|
|
}
|
|
|
|
|
|
// Eingabefeld Lieferantenname freigegeben
|
|
if( (!doc.field[Const.gDDF_LNAME].equals("") && doc.field[Const.gDDF_LNAME] != null) && (doc.getType().getId().equals(Const.gDTS_DLIKO) ) ) {
|
|
|
|
lReturn = doc.field[Const.gDDF_LNAME].indexOf("|")
|
|
if( lReturn > 0 ) {
|
|
String[] splittedString = doc.field[Const.gDDF_LNAME].split("\\|")
|
|
lReturn = splittedString.size()
|
|
if( lReturn == 5 ) {
|
|
lLiefName = splittedString[1].trim()
|
|
gTMPLFNr = splittedString[0].trim()
|
|
lLiefSQL = lLiefSQL + " AND dok_dat_feld_${Const.gDDF_LNAME} = '${lLiefName}' "
|
|
}
|
|
} else {
|
|
lLiefName = doc.field[Const.gDDF_LNAME]
|
|
lLiefSQL = lLiefSQL + " AND dok_dat_feld_${Const.gDDF_LNAME} = '${lLiefName}' "
|
|
}
|
|
} else if( (doc.field[Const.gDDF_LNAME].equals("") || doc.field[Const.gDDF_LNAME] == null) && (doc.getType().getId().equals(Const.gDTS_DLIKO) ) ) {
|
|
d3.log.error( "Es wurde kein Lieferantenname eingegeben." )
|
|
return "Fehler"
|
|
}
|
|
|
|
if( ( gTMPLFNr != null && !gTMPLFNr.equals("") ) && ( doc.field[Const.gDDF_LNR] == null || doc.field[Const.gDDF_LNR].equals("") ) ) {
|
|
lLiefSQL = lLiefSQL + " AND dok_dat_feld_${Const.gDDF_LNR} = '${gTMPLFNr}' "
|
|
}
|
|
|
|
if( doc.getType().getId().equals(Const.gDTS_ALIKO) || doc.getType().getId().equals(Const.gDTS_ALONT) || doc.getType().getId().equals(Const.gDTS_DLIMA) ) {
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_LNR} as lLiefNr2, dok_dat_feld_${Const.gDDF_LNAME} as lLiefName2 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ALIEF}' ${lLiefSQL} "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
lLiefAnz = sqlResult.size()
|
|
} else {
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_LNR} as lLiefNr2, dok_dat_feld_${Const.gDDF_LNAME} as lLiefName2 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ALIKO}' ${lLiefSQL} "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
lLiefAnz = sqlResult.size()
|
|
}
|
|
|
|
if( lLiefAnz >= 1 || ( lLiefAnz == 0 && doc.getType().getId().equals(Const.gDTS_ALIKO) ) ) {
|
|
gTMPLFNr = ""
|
|
return "OK"
|
|
} else {
|
|
gTMPLFNr = ""
|
|
return "Fehler"
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see
|
|
* @return
|
|
*/
|
|
public static String validateLiefNum( D3Interface d3, Document doc, def pEntry ) {
|
|
d3.log.info("Start Functions validateLiefNum = " + doc.getType().getId());
|
|
|
|
// Die Validierung erfolgt über die d.3 Akte "Lieferantenakte" (ALIEF)
|
|
// Ausnahme: Lieferantenkontaktdokument (DLIMA), hier wird die Lieferantenauswahl anhand Projekt/Opportunitynummer eingeschränkt
|
|
|
|
def lLiefSQL
|
|
def lOppNr
|
|
def lAuftrNr
|
|
def lKdNr
|
|
def lLiefAnz
|
|
def lLiefNr
|
|
def lLiefName
|
|
def lReturn
|
|
|
|
if( doc.getType().getId().equals(Const.gDTS_ALIKO) ) {
|
|
d3.log.info( "Überprüfung der Lieferantennummer ${doc.getType().getId()}")
|
|
|
|
lLiefName = doc.field[Const.gDDF_LNAME]
|
|
lLiefNr = doc.field[Const.gDDF_LNR]
|
|
|
|
if( lLiefName != null && !lLiefName.equals("") ) {
|
|
lReturn = lLiefName.indexOf("|")
|
|
if(lReturn > 0) {
|
|
String[] splittedString = lLiefName.split("\\|")
|
|
lLiefName = splittedString[0].trim()
|
|
}
|
|
}
|
|
if( lLiefNr != null && !lLiefNr.equals("") ) {
|
|
lReturn = lLiefNr.indexOf("|")
|
|
if(lReturn > 0) {
|
|
String[] splittedString = lLiefNr.split("\\|")
|
|
lReturn = splittedString.size()
|
|
lLiefNr = splittedString[0].trim()
|
|
}
|
|
}
|
|
|
|
// wenn der Lieferantenname gefüllt ist, aber die Lieferantennummer nicht
|
|
if( (!doc.field[Const.gDDF_LNAME].equals("") && doc.field[Const.gDDF_LNAME] != null) && (doc.field[Const.gDDF_LNR].equals("") || doc.field[Const.gDDF_LNR] == null) ) {
|
|
|
|
// Prüfung ob Lieferantenname einen "neuen" Wert enthält
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_LNR} as lLiefNr2, dok_dat_feld_${Const.gDDF_LNAME} as lLiefName2 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ALIEF}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_LNAME} = '${lLiefName}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
lLiefAnz = sqlResult.size()
|
|
|
|
// wenn nein, dann fehlt die Lieferantennummer
|
|
if( lLiefAnz >= 1 ) {
|
|
return "Fehler"
|
|
}
|
|
// wenn ja - ist alles in Ordnung
|
|
if( lLiefAnz == 0 ) {
|
|
return "OK"
|
|
}
|
|
|
|
}
|
|
|
|
// wenn der Lieferantname gefüllt ist, muss geprüft werden, ob die Lieferantennummer korrekt ist
|
|
if( (!doc.field[Const.gDDF_LNAME].equals("") && doc.field[Const.gDDF_LNAME] != null) && (!doc.field[Const.gDDF_LNR].equals("") && doc.field[Const.gDDF_LNR] != null) ) {
|
|
|
|
// Prüfung ob die Lieferantennummer mit Lieferantenname übereinstimmt
|
|
def sqlStatement = "SELECT dok_dat_feld_${Const.gDDF_LNR} as lLiefNr2, dok_dat_feld_${Const.gDDF_LNAME} as lLiefName2 " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_ALIEF}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_LNAME} = '${lLiefName}' " +
|
|
"AND dok_dat_feld_${Const.gDDF_LNR} = '${lLiefNr}' "
|
|
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
lLiefAnz = sqlResult.size()
|
|
|
|
// wenn ja - ist alles In Ordnung
|
|
if( lLiefAnz >= 1 ) {
|
|
return "OK"
|
|
}
|
|
// wenn nein - dann ist die Lieferantennummer nicht valide
|
|
if( lLiefAnz == 0 ) {
|
|
return "Fehler"
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Validierung der Materialnummer gegen Bestandsakten
|
|
* @author
|
|
* @see Insert, Update, NewVersion
|
|
* @see validateMaterialNo
|
|
* @return Fehlerausgabe wenn die Materialnummern nicht valide ist
|
|
*/
|
|
public static String validateMaterialNum(D3Interface d3, Document doc) {
|
|
String returnValue = null;
|
|
if(doc.getType().getId().equals(Const.gDTS_DMATE)) {
|
|
|
|
d3.log.info("Start Functions validateMaterialNum - " + doc.getType().getId() + " und " + doc.field[Const.gDDF_MATERIALNUMMER]);
|
|
|
|
// Die Validierung erfolgt über die d.3 Akte "Materialakte" (AMATE)
|
|
if(doc.field[Const.gDDF_MATERIALNUMMER] != null) {
|
|
|
|
d3.log.info("Überprüfung der Materialnummer ${doc.field[Const.gDDF_MATERIALNUMMER]}");
|
|
|
|
// Prüfung ob Lieferantenname einen "neuen" Wert enthält
|
|
String sqlStatement = """SELECT doku_id
|
|
FROM firmen_spezifisch
|
|
WHERE kue_dokuart = ?
|
|
AND dok_dat_feld_${Const.gDDF_MATERIALNUMMER} = ? """;
|
|
List<Object> params = [
|
|
Const.gDTS_AMATE,
|
|
doc.field[Const.gDDF_MATERIALNUMMER]
|
|
];
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement, params);
|
|
|
|
if(sqlResult != null) {
|
|
|
|
d3.log.info("Info Functions validateMaterialNum - Anzahl = " + sqlResult.size());
|
|
|
|
if( sqlResult.size() > 0 ) {
|
|
returnValue = "OK";
|
|
} else {
|
|
returnValue = "ERROR";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return returnValue;
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author Maschinenprojekt, Entwicklungsprojekt, Opportunity
|
|
* @see Insert, Update, NewVersion
|
|
* @see validateSAPMaterialNo
|
|
* @return Fehlerausgabe wenn die Mustermaterialnummern nicht valide ist
|
|
*/
|
|
public static int validateMustermaterialNr( D3Interface d3, Document doc, Document docTemp, DocumentType docType, String entryPoint) {
|
|
d3.log.info("Start Functions validateMustermaterialNr");
|
|
|
|
def lReturn
|
|
if( docType.getId().equals(Const.gDTS_DMEOP) || docType.getId().equals(Const.gDTS_DMSPE) || docType.getId().equals(Const.gDTS_DOPPD) ) {
|
|
if(entryPoint.equals("Update") || entryPoint.equals("NewVersion")) {
|
|
// d3.log.error( "Multi Field" )
|
|
if(docTemp != null) {
|
|
for (int i=1; i < Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if( (doc.field[Const.gDDF_MUSTERMATNR69][i] != null && !doc.field[Const.gDDF_MUSTERMATNR69][i].equals("") ) && !doc.field[Const.gDDF_MUSTERMATNR69][i].equals(docTemp.field[Const.gDDF_MUSTERMATNR69][i]) ) {
|
|
// d3.log.error( "pDocTypeShort: ${docType.getId()} Mustermaterial Mehrfachfeld 60: ${:(doc.field[Const.gDDF_MUSTERMATNR69][i]})")
|
|
String[] splittedString = doc.field[Const.gDDF_MUSTERMATNR69][i].split(" \\| ")
|
|
if(splittedString != null) {
|
|
lReturn = splittedString.size()
|
|
|
|
if( lReturn == 2 ) {
|
|
def convertedString = splittedString[0].trim()
|
|
doc.field[Const.gDDF_MUSTERMATNR69][i] = convertedString
|
|
// d3.log.info( "Eingabe: dok_dat_feld[{$Const.gDDF_MUSTERMATNR}]: ${doc.field[Const.gDDF_MUSTERMATNR]})\"" )
|
|
}
|
|
lReturn = validateSAPMaterialNo( d3, doc, doc.field[Const.gDDF_MUSTERMATNR69][i] )
|
|
if( lReturn.equals("FEHLER") ) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT004049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT004001)
|
|
}
|
|
d3.log.error( "Bitte waehlen Sie eine gültige Mustermaterialnummer aus." )
|
|
return -170
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if(entryPoint.equals("Insert")) {
|
|
for (int i=1; i < Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if(doc.field[Const.gDDF_MUSTERMATNR69][i] != null ) {
|
|
String[] splittedString = doc.field[Const.gDDF_MUSTERMATNR69][i].split(" \\| ")
|
|
if(splittedString != null) {
|
|
lReturn = splittedString.size()
|
|
if( lReturn == 2 ) {
|
|
doc.field[Const.gDDF_MUSTERMATNR69][i] = splittedString[0].trim()
|
|
}
|
|
lReturn = Functions.validateSAPMaterialNo( d3, doc, doc.field[Const.gDDF_MUSTERMATNR69][i] )
|
|
if( lReturn.equals("FEHLER") ) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT004049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT004001)
|
|
}
|
|
d3.log.error( "Bitte waehlen Sie eine gültige Mustermaterialnummer aus." )
|
|
return -170
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see
|
|
* @return
|
|
*/
|
|
public static int validateNetzPSP( D3Interface d3, Document doc ) {
|
|
d3.log.info("Start Functions validateNetzPSP");
|
|
|
|
def lReturnNetzplan
|
|
def lReturnPSPElement
|
|
def lPSPElement
|
|
int lInvalidData
|
|
def lECRAtivityID
|
|
def lECRDescription
|
|
def lRowCount
|
|
|
|
if( doc.field[Const.gDDF_NPN] != null && !doc.field[Const.gDDF_NPN].equals("") ) {
|
|
|
|
String[] splittedString = doc.field[Const.gDDF_NPN].split("\\|")
|
|
if(splittedString != null) {
|
|
lReturnNetzplan = splittedString.size()
|
|
if( lReturnNetzplan > 1 ) {
|
|
doc.field[Const.gDDF_NPN] = splittedString[0].trim()
|
|
doc.field[Const.gDDF_PSPELEMENT] = splittedString[1].trim()
|
|
if( lReturnNetzplan > 2 ) {
|
|
if(splittedString[2] != null || !splittedString[2].equals("")) {
|
|
doc.field[Const.gDDF_MASCHINENTYP] = splittedString[2].trim();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Projektnummer ist Pflichtfeld und ob Netzplan gefüllt bereits doch Hook geprüft
|
|
URL url = new URL("https://" + SystemSpecificConst.baseOdata + "/sap/opu/odata/sap/ZCA_D3_VALUE_LISTS_SRV/ProjectNetworkRelationSet?\$filter=ProjExtId%20eq%20'${doc.field[Const.gDDF_AUFTRNR].trim()}'%20and%20NetworkNo%20eq%20'${doc.field[Const.gDDF_NPN].trim()}'&\$format=json");
|
|
|
|
try {
|
|
if(url != null) {
|
|
|
|
URLConnection con = url.openConnection();
|
|
|
|
String userpass = SystemSpecificConst.lUserOdata + ":" + SystemSpecificConst.lPassOdata;
|
|
String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userpass.getBytes()));
|
|
con.setRequestProperty ("Authorization", basicAuth);
|
|
|
|
InputStream is = con.getInputStream();
|
|
String responseValue = IOUtils.toString(is, "UTF-8");
|
|
is.close();
|
|
|
|
JSONObject obj = new JSONObject(responseValue);
|
|
|
|
JSONArray arr = obj.get("d").getJSONArray("results");
|
|
|
|
def Anzahl_Treffer = arr.length()
|
|
def ergebnis
|
|
int lDataOK = 0
|
|
for(int i = 0; i<Anzahl_Treffer && lDataOK != 1; i++) {
|
|
JSONObject metadataObj = arr.getJSONObject(i);
|
|
lPSPElement = metadataObj.getString("PSPElement");
|
|
|
|
if(lPSPElement != null) {
|
|
lPSPElement = lPSPElement.trim();
|
|
if( lPSPElement.equals(doc.field[Const.gDDF_PSPELEMENT]) ) {
|
|
lDataOK = 1
|
|
}
|
|
}
|
|
}
|
|
if( lDataOK == 0 ) {
|
|
lInvalidData = 4
|
|
}
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("validateNetzPSP - Verbindung zu OData nicht möglich")
|
|
// Meldung an den Benutzer, dass die Projektnummer gefüllt werden muss
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", "Keine Verbindung zu SAP, bitte versuchen Sie es spaeter noch einmal.")
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", "No SAP connection, please try again later.")
|
|
}
|
|
d3.log.error( "Keine Verbindung zu SAP, bitte versuchen Sie es spaeter noch einmal = " + e);
|
|
return 1
|
|
}
|
|
|
|
if(lInvalidData == 4 ) {
|
|
// Meldung an den Benutzer, dass die Projektnummer gefüllt werden muss
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", "Die Netzplannummer und das PSP Element passen nicht zusammen, bitte waehlen Sie eine Netzplannummer über die Auswahlliste aus.")
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", "The Netzplannumber does not fit to the PSP Element, please choose the Netzplannumber out of the drop down menue.")
|
|
}
|
|
d3.log.error( "Die Netzplannummer und das PSP Element passen nicht zusammen, bitte waehlen Sie eine Netzplannummer über die Auswahlliste aus." )
|
|
return 1
|
|
}
|
|
|
|
} else {
|
|
// wenn NetzplanNr entfernt wird, müssen auch alle anderen abhängigen Felder geleert werden
|
|
doc.field[Const.gDDF_NPN] = ""
|
|
doc.field[Const.gDDF_PSPELEMENT] = ""
|
|
doc.field[Const.gDDF_MASCHINENTYP] = ""
|
|
}
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* Prüfung ob sowohl eine Projektnummer, als auch eine Opportunity-Nr oder keine der Nummern eingetragen wurde
|
|
* @author Maschinenprojekt, Opportunity
|
|
* @see Insert
|
|
* @see Update
|
|
* @see NewVersion
|
|
* @return Wenn nicht valide, dann Ausgabe einer Hinweismeldung an den Benutzer
|
|
*/
|
|
public static String validateOppProjNr( D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions validateOppProjNr");
|
|
|
|
def sqlStatementOppM = "SELECT ft1.kue_dokuart as dokuArt " +
|
|
"FROM fispe_titel_dokuart ft1 " +
|
|
"LEFT JOIN fispe_titel_dokuart ft2 ON ft1.kue_dokuart = ft2.kue_dokuart " +
|
|
"WHERE ft1.repository_id = '${SystemSpecificConst.gProjektNrID}' " +
|
|
"AND ft2.repository_id = '${SystemSpecificConst.gOpportunityNrID}' " +
|
|
"GROUP BY ft1.kue_dokuart"
|
|
|
|
List<GroovyRowResult> sqlResultOppProj = d3.sql.executeAndGet(sqlStatementOppM);
|
|
List<String> dokuartenOppProj = new ArrayList<>()
|
|
if(sqlResultOppProj != null) {
|
|
for(GroovyRowResult grr : sqlResultOppProj) {
|
|
dokuartenOppProj.add(grr.get("dokuArt"))
|
|
}
|
|
}
|
|
if(dokuartenOppProj.contains(doc.getType().getId())) {
|
|
//Maschinenprojekt: Wenn weder eine Auftrags- noch eine Opportunity-Nr. eingetragen wird, verhindere die Ablage
|
|
if( (doc.field[Const.gDDF_AUFTRNR] == null) && (doc.field[Const.gDDF_OPPNUMMER] == null ) ) {
|
|
|
|
def knrTemp = doc.field[Const.gDDF_KNR]
|
|
|
|
if( ( doc.getType().getId().equals(Const.gDTS_AKUKO) || doc.getType().getId().equals(Const.gDTS_AKONT) || doc.getType().getId().equals(Const.gDTS_DKUKO) ) && knrTemp != null ) {
|
|
// Do nothing, Sonderfall: Ablage zum Kunden
|
|
} else {
|
|
d3.log.error( "Sie versuchen ein Dokument zu importieren, ohne entweder eine Projekt- oder eine Opportunitynummer eingetragen zu haben. Bitte korrigieren Sie Ihre Eingabe." )
|
|
return "WITHOUTPROJOPP"
|
|
}
|
|
} else if( (!doc.field[Const.gDDF_AUFTRNR].equals("") && doc.field[Const.gDDF_AUFTRNR] != null) && (!doc.field[Const.gDDF_OPPNUMMER].equals("") && doc.field[Const.gDDF_OPPNUMMER] != null) && !doc.getType().getId().equals(Const.gDTS_DMEOP) ) {
|
|
d3.log.error( "Sie versuchen ein Dokument zu importieren, und haben sowohl eine Projekt- als auch eine Opportunitynummer eingetragen. Bitte korrigieren Sie Ihre Eingabe." )
|
|
return "PROJOPP"
|
|
}
|
|
}
|
|
return "BEENDET"
|
|
}
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see
|
|
* @return
|
|
*/
|
|
public static void validateProcess(D3Interface d3, Document doc) {
|
|
if(doc != null && doc.getType() != null) {
|
|
d3.log.info("Start Functions validateProcess - " + doc.getType().getId());
|
|
|
|
//Validiert die Prozessart abhängig vom Prozess für Dokumentarten, bei denen die Eigenschaft Prozessart definiert ist
|
|
//Aussnamhe bei der Aktenart Prozessart
|
|
|
|
def sqlStatement = "SELECT * FROM fispe_titel_dokuart WHERE kue_dokuart = '${doc.getType().getId()}' and repository_id = '${SystemSpecificConst.gRepIDProzessart}'"
|
|
def sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
|
|
if(sqlResult != null) {
|
|
if( sqlResult.size() == 1 && !doc.getType().getId().equals(Const.gDTS_APROZ) && !doc.getType().getId().equals(Const.gDTS_AAFOL) && doc.field[Const.gDDF_PROZESS] != null && !doc.getType().getId().equals(Const.gDTS_DUMMY ) ) {
|
|
def sqlStatementSec =
|
|
"SELECT DISTINCT dok_dat_feld_${Const.gDDF_PROZESSART} as prozessart FROM firmen_spezifisch " +
|
|
"WHERE kue_dokuart = '${Const.gDTS_AAFOL}' and dok_dat_feld_${Const.gDDF_PROZESS} = '${doc.field[Const.gDDF_PROZESS]}' "
|
|
def sqlResultSec = d3.sql.executeAndGet(sqlStatementSec)
|
|
if(sqlResultSec != null) {
|
|
if ( sqlResultSec.size() == 1) {
|
|
doc.field[Const.gDDF_PROZESSART] = sqlResultSec.getAt(0).get("prozessart")
|
|
} else {
|
|
doc.field[Const.gDDF_PROZESSART] = "Fehler / Error"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validierung der Eingaben für Weitere BelegNr
|
|
* @author Service, Einkauf
|
|
* @see UpdateAttributeEntry, SearchEntry, NewVersionEntry, InsertEntry
|
|
* @return Rückgabe 0 wenn erfolgreich; Rückgabe Zeilennummer wenn nicht erfolgreich
|
|
*/
|
|
public static int validateBelegNr(D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions validateBelegNr");
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitereBelegNrID) ){
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
def lBelegNr = doc.field[Const.gDDF_WEITEREBELEGNR][i];
|
|
def lBelegArt = doc.field[Const.gDDF_BELEGTYP];
|
|
if(lBelegNr != null) {
|
|
String sqlStatement = "SELECT * FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_ASEBE}' AND dok_dat_feld_${Const.gDDF_BELEGNUMMER} = '${lBelegNr}'";
|
|
if(lBelegArt != null) {
|
|
sqlStatement = sqlStatement + " AND dok_dat_feld_${Const.gDDF_BELEGTYP} = '${lBelegArt}'";
|
|
}
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null) {
|
|
if( sqlResult.size() > 0) {
|
|
//return 0;
|
|
} else {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Validierung der Eingaben für Equipment / weitere Equipment
|
|
* @author Equipment
|
|
* @see UpdateAttributeEntry, SearchEntry, NewVersionEntry, InsertEntry
|
|
* @return Rückgabe 0 wenn erfolgreich; Rückgabe Zeilennummer wenn nicht erfolgreich
|
|
*/
|
|
public static int validateEquipment(D3Interface d3, Document doc, User user, boolean checkFurther) {
|
|
if( user != null && user.isMemberOfGroup( Const.gTECHNICAL_GROUP )) {
|
|
// Ausschluss des DVELOP_WEB, da dieser ggf. neue Informationen anliefert
|
|
} else {
|
|
d3.log.info("Start Functions validateEquipment");
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gEquipmentID) == true && checkFurther == false ) {
|
|
if(doc.field[Const.gDDF_EQUIPMENT] != null) {
|
|
// Prüfung ob Split eventuell erfolgen muss
|
|
String currentEquipment = doc.field[Const.gDDF_EQUIPMENT]
|
|
String[] splittedString = currentEquipment.split("\\|");
|
|
if(splittedString != null && splittedString.size() > 0) {
|
|
currentEquipment = splittedString[0];
|
|
}
|
|
String sqlStatement = "SELECT * FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_AEQUI}' AND dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${currentEquipment}'";
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null) {
|
|
if( sqlResult.size() > 0) {
|
|
//return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
} else if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitereEquipmentID) == true && checkFurther == true ) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
String currentEquipment = doc.field[Const.gDDF_WEITEREEQUIPMENT][i];
|
|
if(currentEquipment != null) {
|
|
// Prüfung ob Split eventuell erfolgen muss
|
|
String[] splittedString = currentEquipment.split("\\|");
|
|
if(splittedString != null && splittedString.size() > 0) {
|
|
currentEquipment = splittedString[0];
|
|
}
|
|
String sqlStatement = "SELECT * FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_AEQUI}' AND dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${currentEquipment}'";
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null) {
|
|
if( sqlResult.size() > 0) {
|
|
//return 0;
|
|
} else {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Validierung der Eingaben für Equipments
|
|
* @author Service
|
|
* @see UpdateAttributeEntry, SearchEntry, NewVersionEntry, InsertEntry
|
|
* @return Rückgabe 0 wenn erfolgreich; Rückgabe Zeilennummer wenn nicht erfolgreich
|
|
*/
|
|
public static int validateEquipments(D3Interface d3, Document doc, User user) {
|
|
d3.log.info("Start Functions validateEquipments");
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gEquipmentsID) == true) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if( doc.field[Const.gDDF_EQUIPMENTS][i] != null ) {
|
|
// Prüfung ob Split eventuell erfolgen muss
|
|
String currentEquipment = doc.field[Const.gDDF_EQUIPMENTS][i]
|
|
String[] splittedString = currentEquipment.split(" \\| ");
|
|
if(splittedString != null && splittedString.size() > 0) {
|
|
currentEquipment = splittedString[0].trim();
|
|
}
|
|
String sqlStatement = "SELECT * FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_AEQUI}' AND dok_dat_feld_${Const.gDDF_EQUIPMENT} = '${currentEquipment}'";
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null) {
|
|
if( sqlResult.size() > 0) {
|
|
//return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Validierung der Eingaben für Weitere SrId für den Service
|
|
* @author Service
|
|
* @see UpdateAttributeEntry, SearchEntry, NewVersionEntry, InsertEntry
|
|
* @return Rückgabe 0 wenn erfolgreich; Rückgabe Zeilennummer wenn nicht erfolgreich
|
|
*/
|
|
public static int validateSrId(D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions validateSrId");
|
|
if( checkIfRepoIDExistsInDocType(d3, doc.getType(), SystemSpecificConst.gWeitereSRIDID) ) {
|
|
for(int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
def lSrId = doc.field[Const.gDDF_WEITERESRID][i];
|
|
if(lSrId != null) {
|
|
String sqlStatement = "SELECT * FROM firmen_spezifisch WHERE kue_dokuart = '${Const.gDTS_ASERE}' AND dok_dat_feld_${Const.gDDF_SRID} = '${lSrId}'";
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
if(sqlResult != null) {
|
|
if( sqlResult.size() > 0) {
|
|
//return 0;
|
|
} else {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Beschreibung
|
|
* @author
|
|
* @see
|
|
* @return
|
|
*/
|
|
public static String validateSAPMaterialNo(D3Interface d3, Document doc, def materialNummer) {
|
|
d3.log.info("Start Functions validateSAPMaterialNo");
|
|
|
|
def suchstrName
|
|
def lLanguage
|
|
def lSplitReturn
|
|
def lSearchProj
|
|
def lSearchOpp
|
|
def Anzahl_Treffer
|
|
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
lLanguage = "DE"
|
|
} else if( d3.remote.getLanguage().equals("001") ) {
|
|
lLanguage = "EN"
|
|
} else {
|
|
lLanguage = "DE"
|
|
}
|
|
|
|
// Unterscheidung wurde die Opportunity oder Maschinenprojektnummer eingegeben
|
|
// 08.05.2017 Split der Opportunity oder Projektnummer, falls nötig
|
|
if( doc.field[Const.gDDF_OPPNUMMER] != null && !doc.field[Const.gDDF_OPPNUMMER].equals("") ) {
|
|
String[] splittedString = doc.field[Const.gDDF_OPPNUMMER].split(" \\| ")
|
|
lSplitReturn = splittedString.size()
|
|
if( lSplitReturn > 0 ) {
|
|
lSearchOpp = splittedString[0].trim()
|
|
} else {
|
|
lSearchOpp = doc.field[Const.gDDF_OPPNUMMER]
|
|
}
|
|
} else if( doc.field[Const.gDDF_AUFTRNR] != null && !doc.field[Const.gDDF_AUFTRNR].equals("") ) {
|
|
String[] splittedString = doc.field[Const.gDDF_AUFTRNR].split("\\|")
|
|
lSplitReturn = splittedString.size()
|
|
if( lSplitReturn > 0 ) {
|
|
lSearchProj = splittedString[0].trim()
|
|
} else {
|
|
lSearchProj = doc.field[Const.gDDF_AUFTRNR]
|
|
}
|
|
}
|
|
|
|
JSONArray arrayOData
|
|
// Durch OData zwei Entities notwendig gemäß Herr Kopp
|
|
// -> Project
|
|
if( lSearchProj != null) {
|
|
URL url1 = new URL("https://" + SystemSpecificConst.baseOdata + "/sap/opu/odata/sap/ZCA_D3_VALUE_LISTS_SRV/SampleMaterialProjectRelationSet?\$filter=ProjExtId%20eq%20'${lSearchProj}'%20and%20LanguageIso639_1%20eq%20'${lLanguage}'&\$format=json");
|
|
try {
|
|
if(url1 != null) {
|
|
URLConnection con = url1.openConnection();
|
|
|
|
String userpass = SystemSpecificConst.lUserOdata + ":" + SystemSpecificConst.lPassOdata;
|
|
String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userpass.getBytes()));
|
|
con.setRequestProperty ("Authorization", basicAuth);
|
|
|
|
InputStream is = con.getInputStream();
|
|
String responseValue = IOUtils.toString(is, "UTF-8");
|
|
is.close();
|
|
|
|
JSONObject obj = new JSONObject(responseValue);
|
|
arrayOData = obj.get("d").getJSONArray("results");
|
|
|
|
Anzahl_Treffer = arrayOData.length()
|
|
|
|
if( Anzahl_Treffer == 0 ) {
|
|
return "FEHLER"
|
|
} else {
|
|
// weitere Verarbeitung folgt im weiteren Code
|
|
}
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("validateSAPMaterialNo - OData Project Exception - " + e.getMessage())
|
|
}
|
|
} else if( lSearchOpp != null) {
|
|
URL url1 = new URL("https://" + SystemSpecificConst.baseOdata + "/sap/opu/odata/sap/ZCA_D3_VALUE_LISTS_SRV/SampleMaterialOpportunityRelationSet?\$filter=OpportunityNo%20eq%20'${lSearchOpp}'%20and%20LanguageIso639_1%20eq%20'${lLanguage}'&\$format=json");
|
|
try {
|
|
if(url1 != null) {
|
|
URLConnection con = url1.openConnection();
|
|
|
|
String userpass = SystemSpecificConst.lUserOdata + ":" + SystemSpecificConst.lPassOdata;
|
|
String basicAuth = "Basic " + new String(Base64.getEncoder().encode(userpass.getBytes()));
|
|
con.setRequestProperty ("Authorization", basicAuth);
|
|
|
|
InputStream is = con.getInputStream();
|
|
String responseValue = IOUtils.toString(is, "UTF-8");
|
|
is.close();
|
|
|
|
JSONObject obj = new JSONObject(responseValue);
|
|
arrayOData = obj.get("d").getJSONArray("results");
|
|
|
|
Anzahl_Treffer = arrayOData.length()
|
|
|
|
if( Anzahl_Treffer == 0 ) {
|
|
return "FEHLER"
|
|
} else {
|
|
// weitere Verarbeitung folgt im weiteren Code
|
|
}
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("validateSAPMaterialNo - OData Project Exception - " + e.getMessage())
|
|
}
|
|
}
|
|
|
|
// d3.log.error( "Anzahl Treffer - Opportunity: ${Anzahl_Treffer_Opportunity} , Project: ${Anzahl_Treffer_Project}" )
|
|
|
|
for(int i = 0; i<Anzahl_Treffer; i++) {
|
|
def lMaterialNo
|
|
def lMaterialBezeichnung
|
|
|
|
JSONObject metadataObj = arrayOData.getJSONObject(i);
|
|
|
|
lMaterialNo = metadataObj.getString("MaterialNo");
|
|
lMaterialBezeichnung = metadataObj.getString("ShortText");
|
|
|
|
if( !lMaterialNo.equals("") ) {
|
|
// d3.log.error( "lMaterialNo: ${lMaterialNo}" )
|
|
if( lMaterialNo.equals(materialNummer) ) {
|
|
// d3.log.error( "Gültige Materialnummer ausgewählt" )
|
|
return "OK"
|
|
} else if( i == Anzahl_Treffer-1 ) {
|
|
return "FEHLER"
|
|
}
|
|
} else {
|
|
return "FEHLER"
|
|
}
|
|
}
|
|
return 1
|
|
}
|
|
|
|
/**
|
|
* Split des zusammengesetzten Wertes für Weitere Kunden- oder Lieferantennummer, sowie Validierung der Eingabe
|
|
* @author Lieferanten- und Kundenmanagement
|
|
* @see InsertEntry, UpdateAttributEntry, ValidateUpdateEntry, NewVersionEntry
|
|
* @return 0=gütlig; -170=ungültig
|
|
*/
|
|
public static int validateWeitKundLiefNo(D3Interface d3, Document doc, DocumentType docType) {
|
|
d3.log.info("Start Functions validateWeitKundLiefNo");
|
|
|
|
def lDDFToSplit
|
|
def lDDFToCheck
|
|
def lValueToCheck
|
|
def lSQL
|
|
def lReturn
|
|
def pRowCount
|
|
if( docType.getId().equals(Const.gDTS_DKUMA) ) {
|
|
lDDFToSplit = Const.gDDF_WEITKDNR
|
|
lDDFToCheck = Const.gDDF_KNR
|
|
lSQL = " AND kue_dokuart = '${Const.gDTS_AKUND}' "
|
|
}
|
|
if( docType.getId().equals(Const.gDTS_DLIMA) ) {
|
|
lDDFToSplit = Const.gDDF_WEITLIEFNR
|
|
lDDFToCheck = Const.gDDF_LNR
|
|
lSQL = " AND kue_dokuart = '${Const.gDTS_ALIEF}' "
|
|
}
|
|
|
|
if(lDDFToSplit != null) {
|
|
for( int i=1; i <= Integer.valueOf(d3.config.value("CUR_60ER_FIELD_NR")); i++) {
|
|
if( doc.field[lDDFToSplit][i] != null ) {
|
|
d3.log.info( "Split für ${docType.getId()}: " + doc.field[lDDFToSplit][i] )
|
|
String[] splittedString = doc.field[lDDFToSplit][i].split("\\|")
|
|
lReturn = splittedString.size()
|
|
d3.log.info( "Split für ${docType.getId()} lReturn " + lReturn )
|
|
if( lReturn == 5 ) {
|
|
lValueToCheck = splittedString[0].trim()
|
|
d3.log.info( "Split für ${docType.getId()} lValueToCheck " + lValueToCheck )
|
|
d3.log.info( "Split für ${docType.getId()} lSQL " + lSQL )
|
|
} else {
|
|
lValueToCheck = doc.field[lDDFToSplit][i]
|
|
}
|
|
|
|
def sqlStatement = "SELECT doku_id " +
|
|
"FROM firmen_spezifisch " +
|
|
"WHERE dok_dat_feld_${lDDFToCheck} = '${lValueToCheck}' "
|
|
if(lSQL != null) {
|
|
sqlStatement = sqlStatement + lSQL
|
|
}
|
|
def sqlResult = d3.sql.executeAndGet(sqlStatement)
|
|
pRowCount = sqlResult.size()
|
|
|
|
d3.log.info( "Split für ${docType.getId()} pRowCount " + pRowCount )
|
|
|
|
if( pRowCount == 1 ) {
|
|
doc.field[lDDFToSplit][i] = lValueToCheck
|
|
} else {
|
|
if( docType.getId().equals(Const.gDTS_DKUMA) ) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT022049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT022001)
|
|
}
|
|
}
|
|
if( docType.getId().equals(Const.gDTS_DLIMA) ) {
|
|
if( d3.remote.getLanguage().equals("049") ) {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT023049)
|
|
} else {
|
|
d3.hook.setProperty("additional_info_text", Const.gADITXT023049)
|
|
}
|
|
}
|
|
return -170
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* Hochzählen einer ID in einem Stringsvalue
|
|
* @author allgemeine Hilfsfunktion
|
|
* @return Zahl im Integer-Format
|
|
*/
|
|
public static String getNextId(D3Interface d3, String currrentId, int counterNullValues) {
|
|
d3.log.info("Start Functions getNextId");
|
|
|
|
try {
|
|
int i = Integer.parseInt(currrentId);
|
|
i++;
|
|
return(i.toString().padLeft(counterNullValues, '0'));
|
|
|
|
} catch(Exception e) {
|
|
d3.log.error("Functions - getNextid - Fehler = " + e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Überprüft, ob Ereignisdatum und Dokumenttitel gefüllt sind. Ansonsten werden die Werte der Importdatei gesetzet
|
|
* @author Allgemeine Funktion für Import von Dokumeten über d.3one aus dem Dateisystem
|
|
* @see insertEntry
|
|
* @return Setzt Werte für die entsprechenden docfields
|
|
*/
|
|
public static void validateD3oneMapping(D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions validateD3oneMapping");
|
|
|
|
try {
|
|
def lAppID = d3.remote.getVersion()[0..2];
|
|
if (lAppID != null && lAppID.equals("020")) {
|
|
//Ereignisdatum
|
|
if (doc.field[Const.gDDF_ERDATE] == null || doc.field[Const.gDDF_ERDATE].equals("")) {
|
|
def lEventDate = new Date()
|
|
doc.field[Const.gDDF_ERDATE] = lEventDate
|
|
}
|
|
|
|
//Dokumenttitel
|
|
if (doc.field[Const.gDDF_DOKTITLE] == null || doc.field[Const.gDDF_DOKTITLE].equals("")) {
|
|
def lFileName = doc.getFilename()
|
|
doc.field[Const.gDDF_DOKTITLE] = lFileName
|
|
}
|
|
}
|
|
} catch(Exception e) {
|
|
d3.log.error("Functions - validateD3oneMapping - Fehler = " + e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prüfung der Gültigkeit der ITSM Nummer
|
|
* @author Unterstützende Prozesse
|
|
* @see ValidateInsertEntry, InsertEntry, UpdateEntry, NewVersionEntry
|
|
* @return Setzt die ITSM ID in das entsprechende Feld und verwirft die Beschreibung - wird ID nicht gefunden Return 10
|
|
*/
|
|
public static int checkITSMNumber(D3Interface d3, Document doc) {
|
|
d3.log.info("Start Functions checkITSMNumber");
|
|
|
|
String[] splittedString = doc.field[Const.gDDF_ITSMID].split("\\|")
|
|
if(splittedString != null && splittedString.size() > 0) {
|
|
doc.field[Const.gDDF_ITSMID] = splittedString[0].trim();
|
|
}
|
|
|
|
def sqlStatement = "SELECT * FROM firmen_spezifisch where dok_dat_feld_${Const.gDDF_ITSMID} = '${doc.field[Const.gDDF_ITSMID]}' and kue_dokuart in ('${Const.gDTS_AITSM}') "
|
|
List<GroovyRowResult> sqlResult = d3.sql.executeAndGet(sqlStatement);
|
|
|
|
if( sqlResult == null || sqlResult.size() == 0 ) {
|
|
return 10
|
|
} else {
|
|
return 0
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Ermittelt die Organisationseinheiten anhand der Projektnummer
|
|
* @author Orga-Projekte
|
|
* @see InsertEntry, UpdateEntry
|
|
* @return keine Rückgabe; im Hintergrund werden die Organisationseinheiten gesetzet gesetzt
|
|
*/
|
|
public static int getOrgUnitByID(D3Interface d3, Document doc, DocumentType docType) {
|
|
|
|
def lProjNo = doc.field[Const.gDDF_PROJNR]
|
|
d3.log.info("Start Functions getOrgUnitByID - ${lProjNo}");
|
|
|
|
// Anhand der Projektnummer die Ordg-Einheiten ermitteln
|
|
def sqlStatement = """SELECT mv.value_char as lOrgUn
|
|
FROM firmen_spezifisch fs, firm_spez_mult_val mv
|
|
where fs.dok_dat_feld_${Const.gDDF_PROJNR} = '${lProjNo}'
|
|
and fs.doku_id = mv.doku_id
|
|
and mv.field_no = '${Const.gDDF_ORGEINHEITEN}'
|
|
and fs.kue_dokuart = '${Const.gDTS_APROJ}' """;
|
|
|
|
List<GroovyRowResult> sqlResultBK = d3.sql.executeAndGet(sqlStatement);
|
|
|
|
List<String> lOrgUn = new ArrayList<>();
|
|
for( GroovyRowResult grr : sqlResultBK) {
|
|
String currOrgUn = grr.get("lOrgUn");
|
|
if(currOrgUn != null && !currOrgUn.equals("")) {
|
|
lOrgUn.add(currOrgUn);
|
|
}
|
|
}
|
|
|
|
int count60 = 1
|
|
for(String s : lOrgUn) {
|
|
doc.field[Const.gDDF_ORGEINHEITEN][count60] = s;
|
|
count60 = count60 + 1;
|
|
}
|
|
return 0
|
|
}
|
|
} |