You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
336 lines
11 KiB
336 lines
11 KiB
/* |
|
* de.superx.etl - a package for controlling ETL routines |
|
* Copyright (C) 2021 Daniel Quathamer <danielq@memtext.de> |
|
* |
|
* This package is licensed under the CampusSource License; |
|
* http://www.campussource.de/org/license/ |
|
*/ |
|
package de.superx.etl; |
|
|
|
import java.io.BufferedReader; |
|
import java.io.BufferedWriter; |
|
import java.io.File; |
|
import java.io.FileInputStream; |
|
import java.io.FileNotFoundException; |
|
import java.io.FileOutputStream; |
|
import java.io.FileWriter; |
|
import java.io.IOException; |
|
import java.io.InputStreamReader; |
|
import java.io.OutputStreamWriter; |
|
import java.io.StringReader; |
|
import java.io.StringWriter; |
|
import java.io.UnsupportedEncodingException; |
|
import java.net.URISyntaxException; |
|
import java.util.Enumeration; |
|
import java.util.NoSuchElementException; |
|
import java.util.Properties; |
|
|
|
import javax.xml.parsers.DocumentBuilder; |
|
import javax.xml.parsers.DocumentBuilderFactory; |
|
import javax.xml.parsers.ParserConfigurationException; |
|
import javax.xml.xpath.XPath; |
|
import javax.xml.xpath.XPathConstants; |
|
import javax.xml.xpath.XPathExpressionException; |
|
import javax.xml.xpath.XPathFactory; |
|
|
|
import org.w3c.dom.Document; |
|
import org.w3c.dom.Node; |
|
import org.xml.sax.InputSource; |
|
import org.xml.sax.SAXException; |
|
|
|
import de.superx.servlet.SuperXManager; |
|
|
|
/** |
|
|
|
*/ |
|
public class EtlUtils { |
|
public static final String NEWLINE=System.getProperty("line.separator"); |
|
public static final String PATHSEP=File.separator; |
|
public static String WEBINFDIR=SuperXManager.getWEB_INFPfad(); |
|
public static String SUPERX_DIR=(System.getProperties().containsKey("SUPERX_DIR")? System.getProperty("SUPERX_DIR"):""); |
|
|
|
public static void main(String args[]) { |
|
|
|
try { |
|
String tidInXmlFile=""; |
|
Document mydomres =de.superx.etl.EtlUtils.buildDocumentFromXmlFile("/home/superx/devel_module/community/tomcat/temp/myTempFile6460222908896375059.xml"); |
|
XPathFactory factory = new net.sf.saxon.xpath.XPathFactoryImpl(); |
|
|
|
XPath xPath = factory.newXPath(); |
|
//String searchPath="/etlAction[@name=\"sx_select_mask\"]/unload/row/fld[@name=\"tid\"]"; |
|
String searchPath="/etlAction[@name=\"sx_select_mask\"]/unload[@name=\"unload_maskeninfo\"]/rs/row/fld[@name=\"tid\"]"; |
|
|
|
Node tidNode=(Node) xPath.compile(searchPath).evaluate( |
|
mydomres, XPathConstants.NODE); |
|
if(tidNode!=null) |
|
tidInXmlFile=de.memtext.util.XMLUtils.getTheValue(tidNode); |
|
else |
|
System.out.println("node not found"); |
|
System.out.println(tidInXmlFile); |
|
} catch (FileNotFoundException e) { |
|
// TODO Auto-generated catch block |
|
e.printStackTrace(); |
|
} catch (XPathExpressionException e) { |
|
// TODO Auto-generated catch block |
|
e.printStackTrace(); |
|
} catch (ParserConfigurationException e) { |
|
// TODO Auto-generated catch block |
|
e.printStackTrace(); |
|
} catch (SAXException e) { |
|
// TODO Auto-generated catch block |
|
e.printStackTrace(); |
|
} catch (IOException e) { |
|
// TODO Auto-generated catch block |
|
e.printStackTrace(); |
|
} |
|
} |
|
|
|
public static Properties convertStringToProperty(String inp) throws IOException |
|
{ |
|
Properties myProps = new Properties(); |
|
myProps.load(new StringReader(inp)); |
|
return myProps; |
|
} |
|
public static Properties mergeParamProperties(Properties params, Properties runTimeParams) |
|
|
|
{ |
|
String parsedParam; |
|
Enumeration runTimeParamNames = runTimeParams.propertyNames(); |
|
while (runTimeParamNames.hasMoreElements()) { |
|
String runTimeParamName = (String)runTimeParamNames.nextElement(); |
|
String runTimeParamValue = runTimeParams.getProperty(runTimeParamName); |
|
Enumeration paramNames = params.propertyNames(); |
|
while (paramNames.hasMoreElements()) { |
|
String paramName=(String)paramNames.nextElement(); |
|
String paramValue=params.getProperty(paramName); |
|
if(paramName.equals(runTimeParamName) ) |
|
{ |
|
paramValue=runTimeParamValue; |
|
params.setProperty(paramName, paramValue); |
|
} |
|
if(paramValue.indexOf("$"+runTimeParamName)>-1) |
|
{ |
|
paramValue=de.memtext.util.StringUtils.replace(paramValue,"$"+runTimeParamName, runTimeParamValue); |
|
params.setProperty(paramName, paramValue); |
|
} |
|
|
|
} |
|
} |
|
return params; |
|
|
|
} |
|
public static void initJobEnvironment() |
|
{ |
|
String initVar=""; |
|
if(System.getProperty("WEBINFDIR") ==null) |
|
{ |
|
|
|
try { |
|
initVar=de.superx.servlet.SuperXManager.getWEB_INFPfad(); |
|
if(initVar==null || initVar.equals(".")) |
|
{ |
|
//ermittle webinfdir |
|
initVar=getWebinfDirectory(); |
|
|
|
} |
|
} catch (Exception e) { |
|
// do nothing, try another |
|
} |
|
|
|
WEBINFDIR=initVar; |
|
|
|
} |
|
|
|
if(System.getProperty("SUPERX_DIR") ==null) |
|
{ |
|
SUPERX_DIR=WEBINFDIR+PATHSEP+"conf"+PATHSEP+"edustore"; |
|
|
|
} |
|
|
|
} |
|
private static String getJarName() |
|
{ |
|
return new File(EtlUtils.class.getProtectionDomain() |
|
.getCodeSource() |
|
.getLocation() |
|
.getPath()) |
|
.getName(); |
|
} |
|
|
|
private static boolean runningFromJar() |
|
{ |
|
String jarName = getJarName(); |
|
return jarName.contains(".jar"); |
|
} |
|
|
|
public static String getWebinfDirectory() throws URISyntaxException |
|
{ |
|
if (runningFromJar()) |
|
{ |
|
return getWebinfDirectoryFromJar(); |
|
} else |
|
{ |
|
return getWebinfDirectoryFromClass(); |
|
} |
|
} |
|
|
|
private static String getWebinfDirectoryFromClass() |
|
{ |
|
File f= new File(EtlUtils.class.getProtectionDomain() |
|
.getCodeSource() |
|
.getLocation() |
|
.getPath()+PATHSEP+".."); |
|
String class_path=f.getAbsolutePath(); |
|
return class_path; |
|
|
|
} |
|
|
|
private static String getWebinfDirectoryFromJar() throws URISyntaxException |
|
{ |
|
String pathOfJarFile=new File(EtlUtils.class.getProtectionDomain().getCodeSource().getLocation().toURI().getPath()).getParent(); |
|
String webinfDir=new File(pathOfJarFile+PATHSEP+"..").getAbsolutePath(); |
|
return webinfDir; |
|
|
|
} |
|
/* die folgenden 2 Methoden |
|
* getFileContentsWithEncoding |
|
* saveFileContentsWithEncoding |
|
* sind in kern5.0 in de.superx.util.FileUtils |
|
* wg. abwärtskompatiblität hierhin kopiert, sollten langfristig wieder weg |
|
*/ |
|
public static String getFileContentsWithEncoding(String filePath, String encoding) { |
|
File f = new File(filePath); |
|
if (!f.exists()) { |
|
System.out.println("Fehler: Datei " + filePath + " existiert nicht."); |
|
return null; |
|
} |
|
String fileContents = ""; |
|
if (encoding == null || encoding.trim().equals("")) { |
|
encoding = System.getProperty("file.encoding"); |
|
} |
|
try { |
|
// --- IputStream und OutputStream generieren ---// |
|
FileInputStream fis = new FileInputStream(f); |
|
// Wenn Quelldatei Unicode, dann speziellen Reader nutzen |
|
BufferedReader in; |
|
//BufferedReader ist schneller bei großen Dateien |
|
in = new BufferedReader(new InputStreamReader(fis, encoding)); |
|
// --- Output-Stream der temporären Datei erzeugen ---// |
|
StringWriter out = new StringWriter(); |
|
// --- Verarbeiten der Datei ---// |
|
String text; |
|
text = in.readLine(); |
|
while (text != null) { // Datei nicht leer |
|
out.write(text); |
|
out.write(System.getProperty("line.separator")); |
|
text = in.readLine(); |
|
} |
|
if (!(out == null)) { |
|
fileContents = out.toString(); |
|
} |
|
} catch (FileNotFoundException e) { |
|
// TODO Auto-generated catch block |
|
e.printStackTrace(); |
|
} catch (UnsupportedEncodingException e) { |
|
// TODO Auto-generated catch block |
|
e.printStackTrace(); |
|
} catch (IOException e) { |
|
// TODO Auto-generated catch block |
|
e.printStackTrace(); |
|
} |
|
return fileContents; |
|
} |
|
|
|
public static void saveFileContentsWithEncoding(String filename, String contents, String encoding) throws |
|
|
|
FileNotFoundException, |
|
IOException |
|
{ |
|
|
|
|
|
File f = new File(filename); |
|
BufferedReader in; |
|
BufferedWriter out; |
|
|
|
//Default encoding ist utf-8 |
|
if (encoding == null) encoding = System.getProperty("file.encoding"); |
|
// --- Output-Stream der temporären Datei erzeugen ---// |
|
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f), encoding)); |
|
|
|
out.write(contents); |
|
|
|
out.close(); |
|
|
|
|
|
}//Ende der Methode |
|
|
|
|
|
/*SAX Document aus XML-Datei erzeugen */ |
|
public static Document buildDocumentFromXmlFile(String srcFile) |
|
throws ParserConfigurationException, FileNotFoundException, SAXException, IOException { |
|
Document mydomres; |
|
org.xml.sax.InputSource is; |
|
DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance(); |
|
DocumentBuilder builder = dfactory.newDocumentBuilder(); |
|
FileInputStream in = new FileInputStream(srcFile); |
|
|
|
is=new org.xml.sax.InputSource(in); |
|
mydomres = builder.newDocument(); |
|
mydomres = builder.parse(is); |
|
return mydomres; |
|
} |
|
/*** |
|
* TODO: nach merge in master diese Methode löschen, und auf de.memtext.util.XMLUtils.parseXml(String) verweisen |
|
* @author Witt This function parses XML-containing string into documents while |
|
* preserving the namespaces and is primarily meant to be used withing |
|
* (jUnit) test cases |
|
* @param xmlString |
|
* @return |
|
* @throws ParserConfigurationException |
|
* @throws SAXException |
|
* @throws IOException |
|
*/ |
|
public static Document parseXml(String xmlString) throws ParserConfigurationException, SAXException, IOException { |
|
DocumentBuilderFactory myFactory = DocumentBuilderFactory.newInstance(); |
|
myFactory.setNamespaceAware(true); |
|
DocumentBuilder myBuilder; |
|
myBuilder = myFactory.newDocumentBuilder(); |
|
Document myDocument = myBuilder.parse(new InputSource(new StringReader(xmlString))); |
|
return myDocument; |
|
} |
|
/** |
|
* @param src |
|
* @param tidInXmlFile |
|
* @return |
|
* @throws ParserConfigurationException |
|
* @throws SAXException |
|
* @throws IOException |
|
* @throws XPathExpressionException |
|
*/ |
|
public static boolean isNodeValueInXml(String src, String searchPath, String expectedValue) |
|
throws ParserConfigurationException, SAXException, IOException, XPathExpressionException { |
|
boolean b=false; |
|
Document mydomres =de.superx.etl.EtlUtils.parseXml(src); |
|
XPathFactory factory = new net.sf.saxon.xpath.XPathFactoryImpl(); |
|
|
|
XPath xPath = factory.newXPath(); |
|
|
|
Node myNode=(Node) xPath.compile(searchPath).evaluate( |
|
mydomres, XPathConstants.NODE); |
|
if(myNode!=null) |
|
{ |
|
String foundValue=de.memtext.util.XMLUtils.getTheValue(myNode); |
|
if(!(foundValue==null) && foundValue.trim().equals(expectedValue)) |
|
b=true; |
|
} |
|
return b; |
|
|
|
} |
|
public static String translateReturnCode(int returnCode) |
|
{ |
|
String returnString="Fehlerhaft"; |
|
if(returnCode==0) |
|
returnString="Erfolg"; |
|
return returnString; |
|
} |
|
}
|
|
|