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.
632 lines
20 KiB
632 lines
20 KiB
package de.superx.bin; |
|
/** |
|
* Diese Klasse bereitet die Zeilen der angegebenen ASCII-Dateien für den Upload vor.<br> |
|
+ "Gebrauch: java de.superx.bin.UnlFileConverter -logger:<Pfad zu logging.properties> -IN:<Pfad zur unl-Datei> -OUT:<Pfad zur Ausgabedatei> -INDESCR:<Pfad zum Eingabe-Descriptor> -OUTDESCR:<Pfad zum Ausgabe-Descriptor> -dbproperties:<Pfad zu db.properties> " |
|
+ "-table:<Tabellenname (wenn auch die Tabelle auf Typkompatitibilität gechekct werden soll>." |
|
* @version 0.1 4.7.2003 |
|
* @author Eugen Ermantraut, D. Quathamer*/ |
|
|
|
/* |
|
* Änderungen |
|
* |
|
* 26.8.04 MB XMLUtils.buildDocumentFromFile -> buildDocument |
|
*/ |
|
|
|
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.IOException; |
|
import java.io.InputStreamReader; |
|
import java.io.OutputStreamWriter; |
|
import java.util.logging.LogManager; |
|
import java.util.logging.Logger; |
|
|
|
import org.apache.commons.lang.StringUtils; |
|
import org.w3c.dom.Document; |
|
import org.w3c.dom.Node; |
|
import org.w3c.dom.NodeList; |
|
import org.xml.sax.SAXException; |
|
|
|
import de.memtext.util.GetOpts; |
|
import de.memtext.util.GetOpts.Options; |
|
import de.memtext.util.XMLUtils; |
|
|
|
public class UnlFileConverter { |
|
|
|
/* Klassenvariablen */ |
|
private static String _dateiPfad = ""; |
|
|
|
private static String DELIMITER = "^"; |
|
|
|
private static String _outDateiPfad = ""; |
|
|
|
private static String _tabelle = ""; |
|
|
|
private static String _indescr = ""; |
|
|
|
private static String _outdescr = ""; |
|
|
|
private static String logfile = "../conf/logging.properties"; |
|
|
|
private static String dbpropfile = ""; |
|
|
|
private static String usage = "-------------------------------------\n" |
|
+ "Gebrauch: java de.superx.bin.UnlFileConverter -logger:<Pfad zu logging.properties> -IN:<Pfad zur unl-Datei> -OUT:<Pfad zur Ausgabedatei> -INDESCR:<Pfad zum Eingabe-Descriptor> -OUTDESCR:<Pfad zum Ausgabe-Descriptor> -dbproperties:<Pfad zu db.properties> " |
|
+ "-table:<Tabellenname (wenn auch die Tabelle auf Typkompatitibilität gechekct werden soll>." |
|
+ "\n---------------------------------------------------"; |
|
|
|
private static String indescr_name = ""; |
|
|
|
private static String indescr_dbsystem = ""; |
|
|
|
private static String indescr_app = ""; |
|
|
|
private static String indescr_cmd = ""; |
|
|
|
private static String in_rec_sep = ""; |
|
|
|
private static String in_line_sep = ""; |
|
|
|
private static String in_rec_header = ""; |
|
|
|
private static String in_rec_footer = ""; |
|
|
|
private static String in_header = ""; |
|
|
|
private static String in_header_delim = ""; |
|
|
|
private static boolean in_fixedwidth = false; |
|
|
|
private static String in_escapemode = ""; |
|
|
|
private static String in_chmod = ""; |
|
|
|
private static String out_rec_sep = ""; |
|
|
|
private static String out_line_sep = ""; |
|
|
|
private static String out_rec_header = ""; |
|
|
|
private static String out_rec_footer = ""; |
|
|
|
private static String out_header = ""; |
|
|
|
private static String out_header_delim = ""; |
|
|
|
private static boolean out_fixedwidth = false; |
|
|
|
private static String out_escapemode = ""; |
|
|
|
private static String out_chmod = ""; |
|
|
|
private static int plaintextcount = 0; |
|
|
|
private static Document inDocument; |
|
|
|
private static Document outDocument; |
|
|
|
private static String plaintextTag = "plaintext"; |
|
|
|
private static String[] searchtext = new String[10]; |
|
|
|
private static String[] replacetext = new String[10]; |
|
|
|
private static final String newline = "{newline}"; |
|
|
|
private static final String tab = "{tab}"; |
|
|
|
Logger logger = (Logger) Logger.getLogger(UnlFileConverter.class.toString()); |
|
|
|
public UnlFileConverter() { |
|
} |
|
|
|
public static void main(String[] args) throws FileNotFoundException, IOException { |
|
UnlFileConverter r = new UnlFileConverter(); |
|
GetOpts.setOpts(args); |
|
String isdrin = GetOpts |
|
.isAllRequiredOptionsPresent(new Options[] { Options.opt_logger, Options.opt_in, Options.opt_idescr }); |
|
if (isdrin != null) { |
|
System.err.println("Datei-Pfade werden als Parameter erwartet. Folgende Optionen fehlen: " + isdrin); |
|
r.zeige_hilfe(); |
|
System.exit(1); |
|
} |
|
|
|
// GetOpts myOpts=new GetOpts(); |
|
if (GetOpts.isPresent(Options.opt_logger)) |
|
logfile = GetOpts.getValue(Options.opt_logger); |
|
File f = new File(logfile); |
|
if (!f.exists()) { |
|
throw new IOException("Datei nicht gefunden: " + logfile); |
|
} |
|
FileInputStream ins = new FileInputStream(logfile); |
|
LogManager MyLogManager = java.util.logging.LogManager.getLogManager(); |
|
MyLogManager.readConfiguration(ins); |
|
logfile = MyLogManager.getProperty(".level"); |
|
// logger.info("Using Loggging-Level " + logfile); |
|
if (GetOpts.isPresent(Options.opt_in)) |
|
_dateiPfad = GetOpts.getValue(Options.opt_in); |
|
if (GetOpts.isPresent(Options.opt_out)) |
|
_outDateiPfad = GetOpts.getValue(Options.opt_out); |
|
if (GetOpts.isPresent(Options.opt_idescr)) |
|
_indescr = GetOpts.getValue(Options.opt_idescr); |
|
if (GetOpts.isPresent(Options.opt_odescr)) |
|
_outdescr = GetOpts.getValue(Options.opt_odescr); |
|
if (GetOpts.isPresent(Options.opt_dbprops)) |
|
dbpropfile = GetOpts.getValue(Options.opt_dbprops); |
|
if (GetOpts.isPresent(Options.opt_table)) |
|
if (dbpropfile.equals("")) { |
|
System.err.println( |
|
"Wenn auch die Ziel-Tabelle geprüft werden soll, dann muss dbproperties gesetzt sein."); |
|
System.err.println(usage); |
|
System.exit(1); |
|
} else |
|
_tabelle = GetOpts.getValue(Options.opt_table); |
|
if (args[0].toString().equals("?") || args[0].toString().equals("/?") || args[0].toString().equals("\\?") |
|
|| args[0].toString().toLowerCase().equals("-h") || args[0].toString().toLowerCase().equals("--h")) { |
|
r.zeige_hilfe(); |
|
System.exit(1); |
|
} |
|
|
|
try { |
|
init_descr(); |
|
r.updateFile(_dateiPfad, _outDateiPfad); |
|
System.out.println("Datei: " + _dateiPfad + " nach " + _outDateiPfad + " umgesetzt"); |
|
} catch (Exception e) { |
|
System.err.println(e.toString()); |
|
} |
|
// } |
|
|
|
} // Ende der Methode |
|
|
|
private void updateFile(String inDateiPfad, String outDateiPfad) throws IOException, Exception { |
|
File f = new File(inDateiPfad); |
|
if (!f.exists()) { |
|
throw new Exception("Datei nicht gefunden: " + inDateiPfad); |
|
} |
|
BufferedReader in; |
|
BufferedWriter out; |
|
// --- File-Instanz für temporäre Ergebnis-Datei anlegen ---// |
|
File out_tmp; |
|
if (inDateiPfad.equals(outDateiPfad)) |
|
out_tmp = new File(inDateiPfad + ".tmp2"); |
|
else |
|
out_tmp = new File(outDateiPfad); |
|
// --- IputStream und OutputStream generieren ---// |
|
in = new BufferedReader(new InputStreamReader(new FileInputStream(f))); |
|
// --- Output-Stream der temporären Datei erzeugen ---// |
|
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(out_tmp))); |
|
|
|
// --- Verarbeiten der Datei ---// |
|
String text; |
|
String text2; |
|
String tt; |
|
/* |
|
* char[] cbuf = new char[1024]; while(true) { int status = |
|
* in.read(cbuf,0,1024); if(status == -1) break; //text=cbuf.toString(); |
|
* text=String.valueOf(cbuf); if (text.startsWith(in_rec_header)) text = |
|
* StringUtils.substringAfter(text, in_rec_header); text = createRow(in, text + |
|
* out_rec_header); //in text steht ein Datensatz text = StringUtils.chomp(text, |
|
* in_rec_footer); text += out_rec_footer; text = replacePlainText(text); |
|
* checkTable(text); //Wenn Tabelle gecheckt werden sollte |
|
* |
|
* out.write(text, 0, text.length()); out.write(out_rec_sep); // muss NeuLine |
|
* schreiben da die Zeile ohne eingelesen wird out.flush(); } |
|
*/ |
|
|
|
text = in.readLine(); |
|
while (text != null) { // Datei nicht leer |
|
if (text.startsWith(in_rec_header)) |
|
text = StringUtils.substringAfter(text, in_rec_header); |
|
text = createRow(in, text + out_rec_header); |
|
// in text steht ein Datensatz |
|
text = StringUtils.chomp(text, in_rec_footer); |
|
text += out_rec_footer; |
|
text = replacePlainText(text); |
|
checkTable(text); // Wenn Tabelle gecheckt werden sollte |
|
|
|
out.write(text, 0, text.length()); |
|
out.write(out_rec_sep); |
|
// muss NeuLine schreiben da die Zeile ohne eingelesen wird |
|
out.flush(); |
|
|
|
text = in.readLine(); |
|
|
|
} // Ende der While-Schleife,alle records bearbeitet. |
|
|
|
in.close(); |
|
out.close(); |
|
// --- Umbenennen Quell-Dateien ---// |
|
/* |
|
* String alt = inDateiPfad + ".in"; File altFile = new File(alt); if |
|
* (altFile.exists()) altFile.delete(); |
|
* |
|
* f.renameTo(altFile); |
|
*/ |
|
|
|
// --- Umformatierte temporäre Datei unter dem ursprünglichen Namen ablegen |
|
// ---// |
|
if (inDateiPfad.equals(outDateiPfad)) { |
|
File neuFile = new File(outDateiPfad); |
|
if (neuFile.isFile()) |
|
neuFile.delete(); |
|
if (!out_tmp.renameTo(neuFile)) |
|
logger.severe("Kann " + outDateiPfad |
|
+ " nicht erzeugen! Existiert die Datei bereits? Die umgesetzte Datei befindet sich in " |
|
+ out_tmp.getPath() + System.getProperty("file.separator") + out_tmp.getName()); |
|
else |
|
out_tmp.delete(); |
|
} |
|
|
|
// --- Berechtigung für die neu angelegete Datei neu Vergeben ---// |
|
if (!out_chmod.equals("")) { |
|
if (!chmode(out_chmod, outDateiPfad)) { |
|
logger.severe("Kann Berechtigung nicht ändern " + outDateiPfad); |
|
} |
|
} |
|
// --- Schliessen der Streams und Löschen der temporären Datei ---// |
|
in.close(); |
|
out.close(); |
|
|
|
} |
|
|
|
private String createRow(BufferedReader in, String text) throws IOException { |
|
String tt; |
|
|
|
try { |
|
// System.out.println(text); |
|
if (text.endsWith(in_line_sep) && !in_line_sep.equals("")) { |
|
text = StringUtils.chomp(text, in_line_sep); |
|
text += out_line_sep; |
|
tt = in.readLine(); |
|
if (tt != null) { |
|
text += StringUtils.chomp(tt, in_line_sep); |
|
while (tt.endsWith(in_line_sep)) { |
|
tt = in.readLine(); |
|
if (tt != null) { |
|
|
|
text += out_line_sep + StringUtils.chomp(tt, in_line_sep); |
|
} |
|
// (tt.substring(0,tt.length())); |
|
} |
|
} |
|
} else |
|
text = SxDBUtils.replaceString(text, in_line_sep, out_line_sep); |
|
} catch (Exception e) { |
|
logger.severe("Fehler beim Umsetzen: " + e.toString() + "\n" + text); |
|
throw new IOException(); |
|
} |
|
// Sonderzeichen in xil_proplist abfangen: |
|
// text=SxDBUtils.replaceString(text,"\\000" , "\\\\000"); |
|
return text; |
|
} |
|
|
|
private void checkTable(String text) throws Exception { |
|
if (!_tabelle.equals("") && !_tabelle.equals("null")) { |
|
// Die Datei ist eine entladene Tabelle |
|
// int start=_dateiPfad.indexOf("_",_dateiPfad.length()-4); |
|
// if(start <0 ) |
|
// start=0; |
|
// String tabname=_dateiPfad.substring(start,_dateiPfad.length()-4); |
|
int numFelder = 0; |
|
// System.out.println("Tabelle "+_tabelle+ " DELIM " + DELIMITER); |
|
try { |
|
numFelder = SxDBUtils.fieldCount(_tabelle); |
|
// System.out.println("Felderanzahl:"+numFelder); |
|
} catch (Exception e) { |
|
System.err.println("Fehler beim Abfragen der Tabellen-Metadaten: " + e.toString()); |
|
} |
|
int k = 0; |
|
int i = 0; |
|
int p = 0; |
|
do { |
|
p = text.indexOf(DELIMITER, i); |
|
if (p > 0) { |
|
k++; |
|
i = p + 1; |
|
} |
|
|
|
} while (p > 0); |
|
if (k != numFelder) { |
|
throw new Exception("unl-Datei entspricht nicht der Tabelle in der Datenbank;\nDie Tabelle hat " |
|
+ numFelder + " Felder, die unl-Datei hat " + k + " Felder "); |
|
} |
|
|
|
} |
|
} // Ende der Methode |
|
|
|
private boolean chmode(String inBerechtigung, String inDat) { |
|
String befehl = "chmod " + inBerechtigung + " " + inDat; |
|
try { |
|
Runtime r = Runtime.getRuntime(); |
|
Process p = r.exec(befehl); |
|
int exitCode = p.waitFor(); |
|
} catch (Exception e) { |
|
logger.severe("Error: " + e.toString()); |
|
return false; |
|
} |
|
|
|
return true; |
|
} // Ende der Methode |
|
|
|
private String replacePlainText(String inS) { |
|
String outS = ""; |
|
for (int i = 0; i <= plaintextcount - 1; i++) { |
|
if ((searchtext[i].equals("") && replacetext[i].equals("")) || (searchtext[i].equals(replacetext[i]))) |
|
outS = inS; |
|
else |
|
outS = SxDBUtils.replaceString(inS, searchtext[i], replacetext[i]); |
|
inS = outS; |
|
} |
|
return outS; |
|
} |
|
|
|
/** |
|
* Liefert den Teilsstring von 0 bis zu letzten Delimiterzeichen(Exclusive) |
|
* |
|
* @param inS |
|
* @return String |
|
*/ |
|
private String reorgString(String inS) throws Exception { |
|
int ldPos = inS.lastIndexOf(DELIMITER); |
|
// --- Wenn Delimiter-Zeichen nicht letztes Zeichen im String ist, |
|
// --- muss die Verarbeitung abgebrochen werden---// |
|
|
|
if ((ldPos + 1) < inS.length() || ldPos == -1) |
|
// throw new Exception("Datei ist bereits umgesetzt!"); |
|
return inS; |
|
else |
|
return inS.substring(0, ldPos); |
|
|
|
} // Ende der Methode |
|
|
|
public boolean check_param_ok(String[] inTab) { // --- Anzahl der übergebenen Parameter prüfen ---// |
|
// System.out.println(inTab.length); |
|
if (inTab.length < 2) { |
|
System.out.println("Mindestens 2 Parameter erwartet! Mit -h oder ? rufen sie Hilfe auf."); |
|
return false; |
|
} |
|
// --- Dateinpfad übernehmen ---// |
|
_dateiPfad = inTab[0].trim(); |
|
_outDateiPfad = inTab[1].trim(); |
|
|
|
if (inTab.length >= 3) |
|
DELIMITER = inTab[2].trim(); |
|
// ---Wenn Delimiter-Zeichen übergeben wurde dann übernehmen ---// |
|
if (inTab.length > 3) |
|
_tabelle = inTab[3].toString().trim(); |
|
|
|
return true; |
|
} // Ende der Methode |
|
|
|
/** |
|
* Prüfen der Datei auf Vorhandensein und Leseberechrigung |
|
* |
|
* @param inFile |
|
*/ |
|
private boolean check_Directory(File inFile) { |
|
if (inFile.exists()) { |
|
if (!inFile.isDirectory()) { |
|
System.out.println(inFile + " ist kein Verzeichnis!"); |
|
return false; |
|
} |
|
} else { |
|
System.out.println(inFile + " Verzeichniss nicht gefunden!"); |
|
return false; |
|
} |
|
|
|
return true; |
|
} // Ende der Methode |
|
|
|
private void progEnde() { |
|
System.runFinalization(); |
|
System.exit(0); |
|
} // Ende der Methode |
|
|
|
private static void init_descr() throws IOException, SAXException { |
|
inDocument = XMLUtils.buildDocument(new File(_indescr), false); |
|
NodeList myInNodes = inDocument.getElementsByTagName(plaintextTag); |
|
outDocument = XMLUtils.buildDocument(new File(_outdescr), false); |
|
NodeList myOutNodes = outDocument.getElementsByTagName(plaintextTag); |
|
int i = 0; |
|
for (i = 0; i < myInNodes.getLength(); i++) { |
|
Node myInNode = myInNodes.item(i); |
|
if (myInNode.getNodeType() == Node.TEXT_NODE) |
|
continue; |
|
String plaintexttype = XMLUtils.getAttribValue(myInNode, "type"); |
|
try { |
|
searchtext[i] = XMLUtils.getTheValue(myInNode); |
|
} catch (IllegalArgumentException e) { |
|
searchtext[i] = ""; |
|
} |
|
searchtext[i] = SxDBUtils.replaceString(searchtext[i], tab, "\t"); |
|
searchtext[i] = SxDBUtils.replaceString(searchtext[i], newline, "\n"); |
|
|
|
/* |
|
* if (searchtext[i].equals(tab)) searchtext[i] = "\t"; if |
|
* (searchtext[i].equals(newline)) searchtext[i] = "\n"; |
|
*/ |
|
for (int k = 0; k < myOutNodes.getLength(); k++) { |
|
Node myOutNode = myOutNodes.item(k); |
|
if (XMLUtils.getAttribValue(myOutNode, "type").equals(plaintexttype)) { |
|
|
|
try { |
|
replacetext[i] = XMLUtils.getTheValue(myOutNode); |
|
} catch (IllegalArgumentException e) { |
|
replacetext[i] = ""; |
|
} |
|
replacetext[i] = SxDBUtils.replaceString(replacetext[i], tab, "\t"); |
|
replacetext[i] = SxDBUtils.replaceString(replacetext[i], newline, "\n"); |
|
/* |
|
* if (replacetext[i].equals(tab)) replacetext[i] = "\t"; |
|
* |
|
* if (replacetext[i].equals(newline)) replacetext[i] = "\n"; |
|
*/ |
|
} |
|
} |
|
|
|
} |
|
plaintextcount = i; |
|
try { |
|
Node myNode = XMLUtils.getFirstNode(inDocument, "record-separator"); |
|
in_rec_sep = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
in_rec_sep = newline; |
|
} |
|
if (in_rec_sep.endsWith(newline)) |
|
in_rec_sep = StringUtils.chomp(in_rec_sep, newline); |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(outDocument, "record-separator"); |
|
out_rec_sep = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
out_rec_sep = newline; |
|
} |
|
|
|
if (out_rec_sep.endsWith(newline)) |
|
out_rec_sep = StringUtils.chomp(out_rec_sep, newline) + "\n"; |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(inDocument, "line-separator"); |
|
in_line_sep = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
in_line_sep = newline; |
|
} |
|
|
|
if (in_line_sep.endsWith(newline)) |
|
in_line_sep = StringUtils.chomp(in_line_sep, newline) + "\n"; |
|
try { |
|
Node myNode = XMLUtils.getFirstNode(outDocument, "line-separator"); |
|
out_line_sep = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
out_line_sep = newline; |
|
} |
|
if (out_line_sep.endsWith(newline)) |
|
out_line_sep = StringUtils.chomp(out_line_sep, newline) + "\n"; |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(inDocument, "record-header"); |
|
in_rec_header = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
in_rec_header = ""; |
|
} |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(outDocument, "record-header"); |
|
out_rec_header = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
out_rec_header = ""; |
|
} |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(inDocument, "record-footer"); |
|
in_rec_footer = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
in_rec_footer = ""; |
|
} |
|
try { |
|
Node myNode = XMLUtils.getFirstNode(outDocument, "record-footer"); |
|
out_rec_footer = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
out_rec_footer = ""; |
|
} |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(inDocument, "header"); |
|
in_header = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
in_header = ""; |
|
} |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(outDocument, "header"); |
|
out_header = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
out_header = ""; |
|
} |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(inDocument, "header-delim"); |
|
in_header_delim = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
in_header_delim = "^"; |
|
} |
|
try { |
|
Node myNode = XMLUtils.getFirstNode(outDocument, "header-delim"); |
|
out_header_delim = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
out_header_delim = "^"; |
|
} |
|
String s = ""; |
|
try { |
|
Node myNode = XMLUtils.getFirstNode(inDocument, "fixedwidth"); |
|
s = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
s = ""; |
|
} |
|
if (s.equalsIgnoreCase("true") || s.equalsIgnoreCase("yes")) |
|
in_fixedwidth = true; |
|
else |
|
in_fixedwidth = false; |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(outDocument, "fixedwidth"); |
|
s = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
s = ""; |
|
} |
|
|
|
if (s.equalsIgnoreCase("true") || s.equalsIgnoreCase("yes")) |
|
out_fixedwidth = true; |
|
else |
|
out_fixedwidth = false; |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(inDocument, "escapemode"); |
|
in_escapemode = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
in_escapemode = ""; |
|
} |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(inDocument, "chmod"); |
|
in_chmod = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
in_chmod = ""; |
|
} |
|
try { |
|
Node myNode = XMLUtils.getFirstNode(outDocument, "escapemode"); |
|
out_escapemode = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
out_escapemode = ""; |
|
} |
|
|
|
try { |
|
Node myNode = XMLUtils.getFirstNode(outDocument, "chmod"); |
|
out_chmod = XMLUtils.getTheValue(myNode); |
|
} catch (IllegalArgumentException e) { |
|
out_chmod = ""; |
|
} |
|
|
|
} |
|
|
|
private void zeige_hilfe() { |
|
System.out.println("\n Diese Klasse bereinigt die Zeilen der angegebenen ASCII-Dateien."); |
|
System.out.println(" Es wird der letzte Delimeter-Zeichen aus jeder Zeile entfernt."); |
|
System.out.println("\n Parameter: "); |
|
System.out.println("1. Eingabe-Dateiname mit Pfadangabe "); |
|
System.out.println("2. Ausgabe-Dateiname mit Pfadangabe"); |
|
System.out.println("3. Delimiter-Zeichen(optional)"); |
|
System.out.println( |
|
"4. Tabellenname in der Datenbank, der auf Übereistimmung der Felderanzahl geprüft werden soll (optional, wenn keine Überprüfung, dann 'none')."); |
|
// System.out.println(" Wenn in einer Zeile Zeichen hinter dem letzten |
|
// Delimiter-Zeichen "); |
|
// System.out.println(" wird die Bearbeitung abgebrochen, da es anzunehmen ist |
|
// daß diese Datei"); |
|
// System.out.println(" bereits umgesetzt ist!"); |
|
System.out.println(" Defaultwert fuer Delimiter ist ^. \n"); |
|
} // Ende der Methode |
|
|
|
} // Ende der Klasse
|