SuperX
/
kern
7
0
Fork 0
Code Issues 9 Pull Requests Projects Releases Wiki Activity
SuperX-Kernmodul
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.
127 Commits
10 Branches
0 Tags
1.3 GiB
 
 
 
 
 
 
Tree: ca0df12d0b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ca0df12d0b'
${ noResults }
kern/src/de/superx/bin/SxJasper.java

395 lines
16 KiB
Raw Blame History

package de.superx.bin;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.logging.LogManager;
import java.util.logging.Logger;
import org.w3c.dom.Document;
import de.memtext.util.GetOpts;
import de.memtext.util.GetOpts.Options;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRExporterParameter;
import net.sf.jasperreports.engine.JRParameter;
import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperPrintManager;
import net.sf.jasperreports.engine.export.JRCsvExporter;
import net.sf.jasperreports.engine.export.JRRtfExporter;
import net.sf.jasperreports.engine.export.JRXlsExporter;
import net.sf.jasperreports.engine.query.JRXPathQueryExecuterFactory;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.engine.util.JRXmlUtils;
/**
* @author Daniel Quathamer Projektgruppe SuperX
*
* @
* Dieses Javaprogramm führt JasperReports aus und gibt das Ergebnis aus.<br>
*
*Aufruf: java $JAVA_OPTS -cp "$CP" de.superx.bin.SxJasper -logger:$LOGGER_PROPERTIES -db_properties:$DB_PROPERTIES -JRXML:<JRXML-Datei> -JASPER:<Jasper-Datei> -JRPRINT:<Jrprint-Datei> -XML:<Datei mit XML-Datenquelle> -IGNORE_PAGINATION:<true oder false> -OUT:<Ausgabedatei>
Aktion: sx_jasper führt einen JasperReports-Task aus.
Das Ergebnis wird in eine Datei <Ausgabedatei> ausgegeben
Die Datenbankverbindung ist in $DB_PROPERTIES definiert.
Achtung: Der Workflow ist wie folgt:
Quelldatei.jrxml ist die XML-Beschreibungsdatei des Berichts
Task compile: Quelldatei.jrxml -> Quelldatei.jasper
Quelldatei.jasper ist kompilierte Beschreibungsdatei für den Bericht
Compile wird ausgeführt, wenn nur eine jrxml-Datei und der Logger übergeben wird.
Task fill/fillIgnorePagination: Quelldatei.jasper -> Quelldatei.jrprint
Quelldatei.jrprint enthält mit Daten gefüllte Berichtsvorlage
Task pdf,csv,html,xml,xmlEmbed,rtf,xls,jxl,print: Quelldatei.jrprint -> Ausgabedatei (Default: Quelldatei+Formatspezifische Endung)
Rendering des Berichts wird ausgeführt.
Sonderform run:
Aus vorhandender .jasper-Datei wird direkt eine pdf-Datei erzeugt.
Setzen Sie den Logging-Level in $LOGGER_PROPERTIES auf INFO, um Laufzeiten zu sehen
*/
//Änderungen
public class SxJasper {
private static Connection myDb;
private static Statement st; // Our statement to run queries with
private static DatabaseMetaData dbmd;
// This defines the structure of the database
private static boolean done = false; // Added by CWJ to permit \q command
private static String taskName = "run";
private static String jrxmlFileName = "";
private static String jasperFileName = "";
private static String jrprintFileName = "";
private static String XMLfileName = "";
private static String XSLfileName = "";
private static String ignorePagination = "";
private static String params = "";
private static String logfile = "../conf/logging.properties";
private static String dbpropfile = "../conf/db.properties";
private static SxConnection myConnection = null;
private static String db_driver;
private static String outfile = "";
private static Logger logger = (Logger) Logger.getLogger(SxJasper.class.toString());
private static final String TASK_COMPILE = "compile";
private static final String TASK_FILL = "fill";
private static final String TASK_PRINT = "print";
private static final String TASK_PDF = "pdf";
private static final String TASK_RTF = "rtf";
private static final String TASK_XML = "xml";
private static final String TASK_XML_EMBED = "xmlEmbed";
private static final String TASK_HTML = "html";
private static final String TASK_XLS = "xls";
private static final String TASK_JXL = "jxl";
private static final String TASK_CSV = "csv";
private static final String TASK_RUN = "run";
private static final String TASK_FILL_IGNORE_PAGINATION = "fillIgnorePagination";
private static String usage = "-------------------------------------\nGebrauch: java de.superx.bin.SxJasper -logger=<<Pfad zu logging.properties>> -JRXML=<<jrxml-Datei>> -OUT=<<Ausgabedatei>>(optional) \n---------------------------------------------------";
/**
* @param args
* @throws ClassNotFoundException
* @throws FileNotFoundException
* @throws IOException
* @throws SQLException
*/
public static void go(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException {
if (args.length == 0) {
throw new IllegalArgumentException("Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, outfile) erfoderlich");
}
GetOpts.setOpts(args);
String isdrin = GetOpts.isAllRequiredOptionsPresent(new Options[] {Options.opt_logger,Options.opt_dbprops,Options.opt_jrxml});
if (isdrin != null) {
System.err.println("Folgende Optionen fehlen: " + isdrin);
System.err.println(usage);
System.exit(1);
}
if (GetOpts.isPresent(Options.opt_logger)) logfile = GetOpts.getValue(Options.opt_logger);
if (GetOpts.isPresent(Options.opt_jrxml)) jrxmlFileName = GetOpts.getValue(Options.opt_jrxml);
if (GetOpts.isPresent(Options.opt_jasper))
jasperFileName = GetOpts.getValue(Options.opt_jasper);
else
jasperFileName = de.memtext.util.FileUtils.getFileNameWithoutSuffix(jrxmlFileName) + ".jasper";
if (GetOpts.isPresent(Options.opt_jrPrint))
jrprintFileName = GetOpts.getValue(Options.opt_jrPrint);
else
jrprintFileName = de.memtext.util.FileUtils.getFileNameWithoutSuffix(jrxmlFileName) + ".jrprint";
if (GetOpts.isPresent(Options.opt_xml)) XMLfileName = GetOpts.getValue(Options.opt_xml);
if (GetOpts.isPresent(Options.opt_ignorePagination)) ignorePagination = GetOpts.getValue(Options.opt_ignorePagination);
if (GetOpts.isPresent(Options.opt_xsl)) XSLfileName = GetOpts.getValue(Options.opt_xsl);
if (GetOpts.isPresent(Options.opt_out))
outfile = GetOpts.getValue(Options.opt_out);
if (GetOpts.isPresent(Options.opt_dbprops)) dbpropfile = GetOpts.getValue(Options.opt_dbprops);
if (GetOpts.isPresent(Options.opt_param)) params = GetOpts.getValue(Options.opt_param);
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);
try {
long start = System.currentTimeMillis();
if (!jrxmlFileName.equals("")) {
if (jasperFileName.equals(""))
jasperFileName = JasperCompileManager.compileReportToFile(jrxmlFileName);
else
JasperCompileManager.compileReportToFile(jrxmlFileName, jasperFileName);
logger.info("Compile time : " + (System.currentTimeMillis() - start));
}
if (!jasperFileName.equals("") &&
(GetOpts.isPresent(Options.opt_dbprops) || GetOpts.isPresent(Options.opt_xml) )
)
{
logger.info("Filling " + jasperFileName);
//Preparing parameters
Map parameters = new HashMap();
if (!XMLfileName.equals("")) {
logger.info("XML-Source " + XMLfileName);
Document document = JRXmlUtils.parse(new File(XMLfileName));
parameters.put(JRXPathQueryExecuterFactory.PARAMETER_XML_DATA_DOCUMENT, document);
parameters.put(JRXPathQueryExecuterFactory.XML_DATE_PATTERN, "dd.MM.yyyy HH:mm:ss");
parameters.put(JRXPathQueryExecuterFactory.XML_NUMBER_PATTERN, "###0.00;-###0.00");
parameters.put(JRXPathQueryExecuterFactory.XML_LOCALE, Locale.GERMAN);
parameters.put(JRParameter.REPORT_LOCALE, Locale.GERMAN);
} else
getConnection(logger, dbpropfile);
//parameters.put("ReportTitle", "Rektorenliste");
//parameters.put("FilterClause", "'Boston', 'Chicago', 'Oslo'");
//parameters.put("OrderClause", "City");
if (ignorePagination.equals("true")) {
parameters.put(JRParameter.IS_IGNORE_PAGINATION, Boolean.TRUE);
}
if (jrprintFileName.equals(""))
jrprintFileName = JasperFillManager.fillReportToFile(jasperFileName, parameters, myDb);
else
JasperFillManager.fillReportToFile(jasperFileName, jrprintFileName, parameters, myDb);
logger.info("Filling time : " + (System.currentTimeMillis() - start));
}
if (outfile.endsWith(".prn")) {
JasperPrintManager.printReport(jrprintFileName, true);
logger.info("Printing time : " + (System.currentTimeMillis() - start));
System.exit(0);
}
if (outfile.endsWith(".pdf")) {
JasperExportManager.exportReportToPdfFile(jrprintFileName, outfile);
logger.info("PDF creation time : " + (System.currentTimeMillis() - start));
System.exit(0);
}
if (outfile.endsWith(".rtf")) {
File sourceFile = new File(jrprintFileName);
JasperPrint jasperPrint = (JasperPrint) JRLoader.loadObject(sourceFile);
File destFile = new File(sourceFile.getParent(), outfile);
JRRtfExporter exporter = new JRRtfExporter();
exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());
exporter.exportReport();
logger.info("RTF creation time : " + (System.currentTimeMillis() - start));
System.exit(0);
}
if (outfile.endsWith(".xml")) {
JasperExportManager.exportReportToXmlFile(jrprintFileName, outfile, false);
logger.info("XML creation time : " + (System.currentTimeMillis() - start));
System.exit(0);
}
/*else if (TASK_XML_EMBED.equals(taskName))
{
if(outfile.equals(""))
outfile=jrxmlFileName + ".xml";
JasperExportManager.exportReportToXmlFile(jrprintFileName,outfile, true);
logger.info("XML creation time : " + (System.currentTimeMillis() - start));
System.exit(0);
}*/
if (outfile.endsWith(".htm") || outfile.endsWith(".html")) {
JasperExportManager.exportReportToHtmlFile(jrprintFileName, outfile);
logger.info("HTML creation time : " + (System.currentTimeMillis() - start));
System.exit(0);
}
if (outfile.endsWith(".xls")) {
File sourceFile = new File(jrprintFileName);
JasperPrint jasperPrint = (JasperPrint) JRLoader.loadObject(sourceFile);
File destFile = new File(sourceFile.getParent(), outfile);
JRXlsExporter exporter = new JRXlsExporter();
exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());
//exporter.setParameter(JRXlsExporterParameter.IS_ONE_PAGE_PER_SHEET, Boolean.FALSE);
exporter.exportReport();
logger.info("XLS creation time : " + (System.currentTimeMillis() - start));
System.exit(0);
}
/* else if (TASK_JXL.equals(taskName))
{
File sourceFile = new File(jrprintFileName);
JasperPrint jasperPrint = (JasperPrint)JRLoader.loadObject(sourceFile);
if(outfile.equals(""))
outfile=jasperPrint.getName() + ".jxl.xls";
File destFile = new File(sourceFile.getParent(), outfile);
JExcelApiExporter exporter = new JExcelApiExporter();
exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());
exporter.setParameter(JRXlsExporterParameter.IS_ONE_PAGE_PER_SHEET, Boolean.TRUE);
exporter.exportReport();
logger.info("XLS creation time : " + (System.currentTimeMillis() - start));
System.exit(0);
}*/
if (outfile.endsWith(".csv")) {
File sourceFile = new File(jrprintFileName);
JasperPrint jasperPrint = (JasperPrint) JRLoader.loadObject(sourceFile);
File destFile = new File(sourceFile.getParent(), outfile);
JRCsvExporter exporter = new JRCsvExporter();
exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());
exporter.exportReport();
logger.info("CSV creation time : " + (System.currentTimeMillis() - start));
System.exit(0);
}
/*else if (TASK_RUN.equals(taskName))
{
//Preparing parameters
Map parameters = new HashMap();
//parameters.put("ReportTitle", "Address Report");
//parameters.put("FilterClause", "'Boston', 'Chicago'");
//parameters.put("OrderClause", "City");
if(outfile.equals(""))
outfile=jrxmlFileName+".pdf";
getConnection(logger, dbpropfile);
JasperRunManager.runReportToPdfFile(jrxmlFileName+".jasper",outfile, parameters, myDb);
logger.info("PDF running time : " + (System.currentTimeMillis() - start));
System.exit(0);
}*/
} catch (JRException e) {
e.printStackTrace();
System.exit(1);
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
//getConnection(logger, dbpropfile);
logger.info("SxJasper erfolgreich beendet");
}
/*
* Display some instructions on how to run the example
*/
public static void instructions() {
System.out.println("SuperX @version@\n");
System.out.println("\nDieses Java-Programm führt einen SQL-Ausdruck aus und gibt das Ergebnis aus.\n");
System.out.println("Gebrauch:\n java doquery <Pfad zu logger-properties> <pfad zu db.properties> <sql-Ausdruck> <Ausgabeformat (txt | html | xml)>(optional) <delimiter> <mit Spaltenüberschriften (true | false)>(optional) <Ausgabedatei>(optional)\n");
System.exit(1);
}
public static void main(String args[]) {
try {
go(args);
} catch (Exception ex) {
System.err.println("Doquery Aufruf fehlgeschlagen.\n" + ex);
ex.printStackTrace();
System.exit(1);
}
}
public static void getConnection(Logger logger, String propFile) throws SQLException {
myConnection = new SxConnection();
myConnection.setPropfile(propFile);
logger.config("Starting Connection...");
try {
myDb = myConnection.getConnection();
st = myDb.createStatement();
//st = myDb.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
// java.sql.ResultSet.CONCUR_READ_ONLY);
//st.setFetchSize(100);
dbmd = myDb.getMetaData();
//st = myDb.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
//ResultSet.CONCUR_UPDATABLE);
} catch (Exception e) {
logger.severe("Keine DB-Verbindung: " + e.toString());
throw new SQLException("Keine DB-Verbindung: " + e.toString());
}
db_driver = myConnection.m_DriverClass.stringValue();
}
}