| /******************************************************************************* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| *******************************************************************************/ |
| package org.apache.ofbiz.htmlreport; |
| |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.Serializable; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.FileUtil; |
| import org.apache.ofbiz.base.util.StringUtil; |
| import org.apache.ofbiz.base.util.UtilHttp; |
| import org.apache.ofbiz.base.util.UtilProperties; |
| import org.apache.ofbiz.base.util.UtilValidate; |
| import org.apache.ofbiz.htmlreport.util.ReportEncoder; |
| import org.apache.ofbiz.htmlreport.util.ReportStringUtil; |
| |
| /** |
| * HTML report output to be used in report.ftl.<p> |
| * |
| */ |
| public class HtmlReport extends AbstractReport { |
| |
| public static final String module = HtmlReport.class.getName(); |
| |
| /** The delimiter that is used in the resource list request parameter. */ |
| public static final String DELIMITER_RESOURCES = "|"; |
| |
| /** Request parameter name for the resource list. */ |
| public static final String PARAM_RESOURCELIST = "resourcelist"; |
| |
| /** Constant for a HTML linebreak with added "real" line break. */ |
| protected static final String LINEBREAK = "<br>"; |
| |
| /** |
| * Constant for a HTML linebreak with added "real" line break- |
| * traditional style for report threads that still use XML templates for their output. |
| */ |
| protected static final String LINEBREAK_TRADITIONAL = "<br>\n"; |
| |
| /** The list of report objects e.g. String, Exception ... */ |
| protected List<Serializable> content; |
| |
| /** The list of report objects e.g. String, Exception ... */ |
| protected List<Serializable> logContent; |
| |
| /** |
| * Counter to remember what is already shown, |
| * indicates the next index of the content list that has to be reported. |
| */ |
| protected int indexNext; |
| |
| /** Flag to indicate if an exception should be displayed long or short. */ |
| protected boolean showExceptionStackTrace; |
| |
| /** If set to <code>true</code> nothing is kept in memory. */ |
| protected boolean isTransient; |
| |
| /** Boolean flag indicating whether this report should generate HTML or JavaScript output. */ |
| protected boolean writeHtml; |
| |
| /** Helper variable to deliver the html end part. */ |
| public static final int HTML_END = 1; |
| |
| /** Helper variable to deliver the html start part. */ |
| public static final int HTML_START = 0; |
| |
| /** The thread to display in this report. */ |
| protected String paramThread; |
| |
| /** The next thread to display after this report. */ |
| protected String paramThreadHasNext; |
| |
| protected String paramAction; |
| |
| protected String paramTitle; |
| |
| protected String paramResource; |
| |
| /** Flag for refreching workplace .*/ |
| protected String paramRefreshWorkplace; |
| |
| /** Constant for the "OK" button in the build button methods. */ |
| public static final int BUTTON_OK = 0; |
| |
| /** Constant for the "Cancel" button in the build button methods. */ |
| public static final int BUTTON_CANCEL = 1; |
| |
| /** Constant for the "Close" button in the build button methods. */ |
| public static final int BUTTON_CLOSE = 2; |
| |
| /** Constant for the "Advanced" button in the build button methods. */ |
| public static final int BUTTON_ADVANCED = 3; |
| |
| /** Constant for the "Set" button in the build button methods. */ |
| public static final int BUTTON_SET = 4; |
| |
| /** Constant for the "Details" button in the build button methods. */ |
| public static final int BUTTON_DETAILS = 5; |
| |
| /** Constant for the "OK" button in the build button methods (without form submission). */ |
| public static final int BUTTON_OK_NO_SUBMIT = 6; |
| |
| /** Constant for the "Edit" button in the build button methods (same function as "Ok" button but different text on button. */ |
| public static final int BUTTON_EDIT = 7; |
| |
| /** Constant for the "Discard" button in the build button methods (same function as "Cancel" button but different text on button. */ |
| public static final int BUTTON_DISCARD = 8; |
| |
| /** Constant for the "Back" button in the build button methods. */ |
| public static final int BUTTON_BACK = 9; |
| |
| /** Constant for the "Continue" button in the build button methods. */ |
| public static final int BUTTON_CONTINUE = 10; |
| |
| /** Constant for the "Download" button in the build button methods. */ |
| public static final int BUTTON_DOWNLOAD = 11; |
| |
| /** Request parameter value for the action: back. */ |
| public static final String DIALOG_BACK = "back"; |
| |
| /** Request parameter value for the action: cancel. */ |
| public static final String DIALOG_CANCEL = "cancel"; |
| |
| /** Request parameter value for the action: continue. */ |
| public static final String DIALOG_CONTINUE = "continue"; |
| |
| /** Request parameter value for the action: set. */ |
| public static final String DIALOG_SET = "set"; |
| |
| /** The resource list parameter value. */ |
| protected String paramResourcelist; |
| |
| /** The list of resource names for the multi operation. */ |
| protected List<String> resourceList; |
| |
| /** The key name which contains the localized message for the continue checkbox. */ |
| protected String paramReportContinueKey; |
| |
| public static final String DIALOG_URI = "dialoguri"; |
| |
| public static final String FORM_URI = "formuri"; |
| |
| public static final String resource = "PricatUiLabels"; |
| |
| /** Log file. */ |
| protected File logFile; |
| |
| /** Log file name. */ |
| protected String logFileName; |
| |
| /** Log file output stream. */ |
| protected FileOutputStream logFileOutputStream; |
| |
| protected long sequenceNum = -1; |
| |
| /** |
| * Constructs a new report using the provided locale for the output language.<p> |
| * |
| * @param request HttpServletRequest |
| * @param response HttpServletResponse |
| */ |
| public HtmlReport(HttpServletRequest request, HttpServletResponse response) { |
| |
| this(request, response, false, false); |
| } |
| |
| /** |
| * Constructs a new report using the provided locale for the output language.<p> |
| * |
| * @param request HttpServletRequest |
| * @param response HttpServletResponse |
| * @param writeHtml if <code>true</code>, this report should generate HTML instead of JavaScript output |
| * @param isTransient If set to <code>true</code> nothing is kept in memory |
| */ |
| public HtmlReport(HttpServletRequest request, HttpServletResponse response, boolean writeHtml, boolean isTransient) { |
| |
| init(UtilHttp.getLocale(request)); |
| content = new ArrayList<Serializable>(256); |
| logContent = new ArrayList<Serializable>(256); |
| showExceptionStackTrace = true; |
| this.writeHtml = writeHtml; |
| this.isTransient = isTransient; |
| } |
| |
| public static HtmlReport getInstance(HttpServletRequest request, HttpServletResponse response) { |
| HtmlReport wp = (HtmlReport) request.getSession().getAttribute(SESSION_REPORT_CLASS); |
| if (wp == null) { |
| wp = new HtmlReport(request, response, true, true); |
| request.getSession().setAttribute(SESSION_REPORT_CLASS, wp); |
| } |
| return wp; |
| } |
| |
| public static HtmlReport getInstance(HttpServletRequest request, HttpServletResponse response, boolean writeHtml, boolean isTransient) { |
| HtmlReport wp = (HtmlReport) request.getSession().getAttribute(SESSION_REPORT_CLASS); |
| if (wp == null) { |
| wp = new HtmlReport(request, response, writeHtml, isTransient); |
| request.getSession().setAttribute(SESSION_REPORT_CLASS, wp); |
| } |
| return wp; |
| } |
| |
| public static HtmlReport getInstance(HttpServletRequest request, HttpServletResponse response, boolean writeHtml, boolean isTransient, String logFileName) { |
| HtmlReport wp = (HtmlReport) request.getSession().getAttribute(SESSION_REPORT_CLASS); |
| if (wp == null || UtilValidate.isEmpty(wp.getLogFileName()) || !wp.getLogFileName().equals(logFileName)) { |
| wp = new HtmlReport(request, response, writeHtml, isTransient); |
| request.getSession().setAttribute(SESSION_REPORT_CLASS, wp); |
| } |
| return wp; |
| } |
| |
| public String getParamAction(HttpServletRequest request) { |
| paramAction = request.getParameter("action"); |
| return paramAction != null ? paramAction : "reportbegin"; |
| } |
| |
| public void setParamAction(String action) { |
| paramAction = action; |
| } |
| |
| public void setParamThread(String name) { |
| paramThread = name; |
| } |
| |
| public synchronized String getReportUpdate() { |
| StringBuffer result = new StringBuffer(); |
| StringBuffer logResult = new StringBuffer(); |
| int indexEnd = content.size(); |
| for (int i = indexNext; i < indexEnd; i++) { |
| int pos = isTransient ? 0 : i; |
| Object obj = content.get(pos); |
| if ((obj instanceof String) || (obj instanceof StringBuffer)) { |
| result.append(obj); |
| } else if (obj instanceof Throwable) { |
| result.append(getExceptionElementJS((Throwable)obj)); |
| } |
| if (isTransient) { |
| content.remove(indexNext); |
| } |
| if (UtilValidate.isNotEmpty(logContent)) { |
| Object logObj = logContent.get(pos); |
| if ((logObj instanceof String) || (logObj instanceof StringBuffer)) { |
| logResult.append(logObj); |
| } else if (logObj instanceof Throwable) { |
| result.append(getExceptionElementHtml((Throwable) logObj)); |
| } |
| if (isTransient) { |
| logContent.remove(indexNext); |
| } |
| } |
| } |
| |
| indexNext = isTransient ? 0 : indexEnd; |
| |
| if (isTransient && logFileOutputStream != null && logResult.toString().length() > 0) { |
| try { |
| logFileOutputStream.write((logResult.toString() + "\n").getBytes()); |
| logFileOutputStream.flush(); |
| } catch (IOException e) { |
| Debug.logError(e.getMessage(), module); |
| } |
| } |
| return result.toString(); |
| } |
| |
| /** |
| * Returns if the report writes html or javascript code.<p> |
| * |
| * @return <code>true</code> if the report writes html, and <code>false</code> if the report writes javascript code |
| */ |
| public boolean isWriteHtml() { |
| return writeHtml; |
| } |
| |
| public synchronized void print(String value, int format) { |
| StringBuffer buf = null; |
| value = ReportStringUtil.escapeJavaScript(value); |
| switch (format) { |
| case FORMAT_HEADLINE: |
| buf = new StringBuffer(); |
| buf.append("aH('"); |
| buf.append(value); |
| buf.append("'); "); |
| break; |
| case FORMAT_WARNING: |
| buf = new StringBuffer(); |
| buf.append("aW('"); |
| buf.append(value); |
| buf.append("'); "); |
| addWarning(value); |
| break; |
| case FORMAT_ERROR: |
| buf = new StringBuffer(); |
| buf.append("aE('"); |
| buf.append(value); |
| buf.append("'); "); |
| addError(value); |
| break; |
| case FORMAT_NOTE: |
| buf = new StringBuffer(); |
| buf.append("aN('"); |
| buf.append(value); |
| buf.append("'); "); |
| break; |
| case FORMAT_OK: |
| buf = new StringBuffer(); |
| buf.append("aO('"); |
| buf.append(value); |
| buf.append("'); "); |
| break; |
| case FORMAT_DEFAULT: |
| default: |
| buf = new StringBuffer(); |
| buf.append("a('"); |
| buf.append(value); |
| buf.append("'); "); |
| } |
| if (value.trim().endsWith(getLineBreak())) { |
| buf.append("aB(); "); |
| } |
| content.add(buf.toString()); |
| |
| switch (format) { |
| case FORMAT_HEADLINE: |
| buf = new StringBuffer(); |
| buf.append("<span class='head'>"); |
| buf.append(value); |
| buf.append("</span>"); |
| break; |
| case FORMAT_WARNING: |
| buf = new StringBuffer(); |
| buf.append("<span class='warn'>"); |
| buf.append(value); |
| buf.append("</span>"); |
| addWarning(value); |
| break; |
| case FORMAT_ERROR: |
| buf = new StringBuffer(); |
| buf.append("<span class='err'>"); |
| buf.append(value); |
| buf.append("</span>"); |
| addError(value); |
| break; |
| case FORMAT_NOTE: |
| buf = new StringBuffer(); |
| buf.append("<span class='note'>"); |
| buf.append(value); |
| buf.append("</span>"); |
| break; |
| case FORMAT_OK: |
| buf = new StringBuffer(); |
| buf.append("<span class='ok'>"); |
| buf.append(value); |
| buf.append("</span>"); |
| break; |
| case FORMAT_DEFAULT: |
| default: |
| buf = new StringBuffer(value); |
| } |
| if (value.trim().endsWith(getLineBreak())) { |
| buf.append("\n"); |
| } |
| logContent.add(buf.toString()); |
| } |
| |
| public void println() { |
| print(getLineBreak()); |
| } |
| |
| public synchronized void println(Throwable t) { |
| addError(t.getMessage()); |
| content.add(getExceptionElementJS(t)); |
| logContent.add(getExceptionElementHtml(t)); |
| } |
| |
| /** |
| * Returns the correct line break notation depending on the output style of this report. |
| * |
| * @return the correct line break notation |
| */ |
| protected String getLineBreak() { |
| return writeHtml ? LINEBREAK_TRADITIONAL : LINEBREAK; |
| } |
| |
| /** |
| * Output helper method to format a reported <code>Throwable</code> element.<p> |
| * |
| * This method ensures that exception stack traces are properly escaped |
| * when they are added to the report.<p> |
| * |
| * There is a member variable {@link #showExceptionStackTrace} in this |
| * class that controls if the stack track is shown or not. |
| * In a later version this might be configurable on a per-user basis.<p> |
| * |
| * @param throwable the exception to format |
| * @return the formatted StringBuffer |
| */ |
| private StringBuffer getExceptionElementJS(Throwable throwable) { |
| StringBuffer buf = new StringBuffer(256); |
| if (showExceptionStackTrace) { |
| buf.append("aT('"); |
| buf.append(UtilProperties.getMessage(resource, "REPORT_EXCEPTION", getLocale())); |
| String exception = ReportEncoder.escapeXml(throwable.getLocalizedMessage()); |
| if (UtilValidate.isEmpty(exception)) { |
| exception = ReportEncoder.escapeXml(throwable.getMessage()); |
| } |
| if (UtilValidate.isNotEmpty(exception)) { |
| exception = exception.replaceAll("[\r\n]+", LINEBREAK); |
| buf.append(ReportStringUtil.escapeJavaScript(exception) + LINEBREAK); |
| } else { |
| buf.append(throwable.toString()); |
| } |
| buf.append("'); "); |
| } else { |
| buf.append("aT('"); |
| buf.append(UtilProperties.getMessage(resource, "REPORT_EXCEPTION", getLocale())); |
| buf.append(ReportStringUtil.escapeJavaScript(throwable.toString())); |
| buf.append("'); "); |
| } |
| return buf; |
| } |
| |
| private StringBuffer getExceptionElementHtml(Throwable throwable) { |
| StringBuffer buf = new StringBuffer(256); |
| if (showExceptionStackTrace) { |
| buf.append("<span class='throw'>"); |
| buf.append(UtilProperties.getMessage(resource, "REPORT_EXCEPTION", getLocale())); |
| String exception = ReportEncoder.escapeXml(throwable.getLocalizedMessage()); |
| if (UtilValidate.isEmpty(exception)) { |
| exception = ReportEncoder.escapeXml(throwable.getMessage()); |
| } |
| if (UtilValidate.isNotEmpty(exception)) { |
| exception = exception.replaceAll("[\r\n]+", LINEBREAK); |
| buf.append(exception); |
| } else { |
| buf.append(throwable.toString()); |
| } |
| buf.append("</span>"); |
| } else { |
| buf.append("<span class='throw'>"); |
| buf.append(UtilProperties.getMessage(resource, "REPORT_EXCEPTION", getLocale())); |
| buf.append(throwable.toString()); |
| buf.append("</span>"); |
| buf.append(getLineBreak()); |
| } |
| return buf; |
| } |
| |
| public void printMessageWithParam(String uiLabel, Object param) { |
| print(uiLabel, InterfaceReport.FORMAT_NOTE); |
| } |
| |
| public void printMessageWithParam(int m, int n, String uiLabel, Object param) { |
| print(uiLabel, InterfaceReport.FORMAT_NOTE); |
| } |
| |
| /** |
| * Builds the start html of the page, including setting of DOCTYPE and |
| * inserting a header with the content-type.<p> |
| * |
| * This overloads the default method of the parent class.<p> |
| * |
| * @return the start html of the page |
| */ |
| public String htmlStart() { |
| |
| return pageHtml(HTML_START, true); |
| } |
| |
| /** |
| * Builds the start html of the page, including setting of DOCTYPE and |
| * inserting a header with the content-type.<p> |
| * |
| * This overloads the default method of the parent class.<p> |
| * |
| * @param loadStyles if true, the defaul style sheet will be loaded |
| * @return the start html of the page |
| */ |
| public String htmlStart(boolean loadStyles) { |
| |
| return pageHtml(HTML_START, loadStyles); |
| } |
| |
| /** |
| * Builds the start html of the page, including setting of DOCTYPE and |
| * inserting a header with the content-type.<p> |
| * |
| * This overloads the default method of the parent class.<p> |
| * |
| * @param segment the HTML segment (START / END) |
| * @param loadStyles if true, the defaul style sheet will be loaded |
| * @return the start html of the page |
| */ |
| public String pageHtml(int segment, boolean loadStyles) { |
| if (segment == HTML_START) { |
| StringBuffer result = new StringBuffer(512); |
| result.append("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\">\n"); |
| result.append("<html>\n<head>\n"); |
| result.append("<meta HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=UTF-8\">\n"); |
| if (loadStyles) { |
| result.append("<link rel=\"stylesheet\" type=\"text/css\" href=\""); |
| result.append("/pricat/includes/pricat.css"); |
| result.append("\">\n"); |
| result.append("<script type=\"text/javascript\">\n"); |
| result.append(dialogScriptSubmit()); |
| result.append("</script>\n"); |
| } |
| return result.toString(); |
| } else { |
| return "</html>"; |
| } |
| } |
| |
| /** |
| * Builds the standard javascript for submitting the dialog.<p> |
| * |
| * @return the standard javascript for submitting the dialog |
| */ |
| public String dialogScriptSubmit() { |
| StringBuffer result = new StringBuffer(512); |
| result.append("function submitAction(actionValue, theForm, formName) {\n"); |
| result.append("\tif (theForm == null) {\n"); |
| result.append("\t\ttheForm = document.forms[formName];\n"); |
| result.append("\t}\n"); |
| result.append("\ttheForm.action.value = actionValue;\n"); |
| result.append("\ttheForm.submit();\n"); |
| result.append("\treturn false;\n"); |
| result.append("}\n"); |
| return result.toString(); |
| } |
| |
| /** |
| * Returns true if the report Thread is still alive (i.e. running), false otherwise.<p> |
| * |
| * @return true if the report Thread is still alive |
| */ |
| public boolean isAlive(HttpServletRequest request) { |
| ThreadGroup threadGroup = Thread.currentThread().getThreadGroup(); |
| int i = threadGroup.activeCount(); |
| Thread[] threads = new Thread[i]; |
| threadGroup.enumerate(threads, true); |
| AbstractReportThread thread = null; |
| for (int j=0; j<threads.length; j++) { |
| Thread threadInstance = threads[j]; |
| if (threadInstance instanceof AbstractReportThread) { |
| if(((AbstractReportThread)threadInstance).getUUID().toString().equals(getParamThread(request))) { |
| thread = (AbstractReportThread) threadInstance; |
| break; |
| } |
| } |
| } |
| if (thread != null) { |
| return thread.isAlive(); |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Returns the thread parameter value.<p> |
| * |
| * @return the thread parameter value |
| */ |
| public String getParamThread(HttpServletRequest request) { |
| String thread = request.getParameter("thread"); |
| return ReportStringUtil.isNotEmptyOrWhitespaceOnly(thread) ? thread : (paramThread == null? "" : paramThread); |
| } |
| |
| /** |
| * Returns the threadhasnext parameter value.<p> |
| * |
| * @return the threadhasnext parameter value |
| */ |
| public String getParamThreadHasNext(HttpServletRequest request) { |
| String threadhasnext = request.getParameter("threadhasnext"); |
| return ReportStringUtil.isNotEmptyOrWhitespaceOnly(threadhasnext) ? threadhasnext : "false"; |
| } |
| |
| /** |
| * Builds the start html of the body.<p> |
| * |
| * @param className optional class attribute to add to the body tag |
| * @param parameters optional parameters to add to the body tag |
| * @return the start html of the body |
| */ |
| public String bodyStart(String className, String parameters) { |
| return pageBody(HTML_START, className, parameters); |
| } |
| |
| /** |
| * Builds the html of the body.<p> |
| * |
| * @param segment the HTML segment (START / END) |
| * @param className optional class attribute to add to the body tag |
| * @param parameters optional parameters to add to the body tag |
| * @return the html of the body |
| */ |
| public String pageBody(int segment, String className, String parameters) { |
| if (segment == HTML_START) { |
| StringBuffer result = new StringBuffer(128); |
| result.append("</head>\n<body unselectable=\"on\""); |
| if (ReportStringUtil.isNotEmptyOrWhitespaceOnly(className)) { |
| result.append(" class=\""); |
| result.append(className); |
| result.append("\""); |
| } |
| if (ReportStringUtil.isNotEmpty(parameters)) { |
| result.append(" "); |
| result.append(parameters); |
| } |
| result.append(">\n"); |
| return result.toString(); |
| } else { |
| return "</body>"; |
| } |
| } |
| |
| /** |
| * Builds the end html of the body.<p> |
| * |
| * @return the end html of the body |
| */ |
| public String bodyEnd() { |
| return pageBody(HTML_END, null, null); |
| } |
| |
| /** |
| * Builds the end html of the page.<p> |
| * |
| * @return the end html of the page |
| */ |
| public String htmlEnd() { |
| return pageHtml(HTML_END, null); |
| } |
| |
| /** |
| * Returns the default html for a workplace page, including setting of DOCTYPE and |
| * inserting a header with the content-type.<p> |
| * |
| * @param segment the HTML segment (START / END) |
| * @param title the title of the page, if null no title tag is inserted |
| * @return the default html for a workplace page |
| */ |
| public String pageHtml(int segment, String title) { |
| return pageHtmlStyle(segment, title, null); |
| } |
| |
| /** |
| * Returns the default html for a workplace page, including setting of DOCTYPE and |
| * inserting a header with the content-type, allowing the selection of an individual style sheet.<p> |
| * |
| * @param segment the HTML segment (START / END) |
| * @param title the title of the page, if null no title tag is inserted |
| * @param stylesheet the used style sheet, if null the default stylesheet 'workplace.css' is inserted |
| * @return the default html for a workplace page |
| */ |
| public String pageHtmlStyle(int segment, String title, String stylesheet) { |
| if (segment == HTML_START) { |
| StringBuffer result = new StringBuffer(512); |
| // result.append("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\">\n"); |
| // result.append("<html>\n<head>\n"); |
| // if (title != null) { |
| // result.append("<title>"); |
| // result.append(title); |
| // result.append("</title>\n"); |
| // } |
| // result.append("<meta HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=UTF-8\">\n"); |
| result.append("<link rel=\"stylesheet\" type=\"text/css\" href=\""); |
| result.append("/pricat/includes/pricat.css"); |
| result.append("\">\n"); |
| return result.toString(); |
| } else { |
| return ""; |
| // return "</html>"; |
| } |
| } |
| |
| /** |
| * Returns the start html for the outer dialog window border. |
| * |
| * @return the start html for the outer dialog window border |
| */ |
| public String dialogStart() { |
| return dialog(HTML_START, null); |
| } |
| |
| /** |
| * Builds the outer dialog window border. |
| * |
| * @param segment the HTML segment (START / END) |
| * @param attributes optional additional attributes for the opening dialog table |
| * |
| * @return a dialog window start / end segment |
| */ |
| public String dialog(int segment, String attributes) { |
| if (segment == HTML_START) { |
| StringBuffer html = new StringBuffer(512); |
| html.append("<table class=\"dialog\" cellpadding=\"0\" cellspacing=\"0\""); |
| if (attributes != null) { |
| html.append(" "); |
| html.append(attributes); |
| } |
| html.append("><tr><td>\n<table class=\"dialogbox\" cellpadding=\"0\" cellspacing=\"0\">\n"); |
| html.append("<tr><td>\n"); |
| return html.toString(); |
| } else { |
| return "</td></tr></table>\n</td></tr></table>\n<p> </p>\n"; |
| } |
| } |
| |
| /** |
| * Returns the start html for the content area of the dialog window.<p> |
| * |
| * @param title the title for the dialog |
| * |
| * @return the start html for the content area of the dialog window |
| */ |
| public String dialogContentStart(String title) { |
| return dialogContent(HTML_START, title); |
| } |
| |
| /** |
| * Builds the content area of the dialog window.<p> |
| * |
| * @param segment the HTML segment (START / END) |
| * @param title the title String for the dialog window |
| * |
| * @return a content area start / end segment |
| */ |
| public String dialogContent(int segment, String title) { |
| if (segment == HTML_START) { |
| StringBuffer result = new StringBuffer(512); |
| // null title is ok, we always want the title headline |
| result.append(dialogHead(title)); |
| result.append("<div class=\"dialogcontent\" unselectable=\"on\">\n"); |
| result.append("<!-- dialogcontent start -->\n"); |
| return result.toString(); |
| } else { |
| return "<!-- dialogcontent end -->\n</div>\n"; |
| } |
| } |
| |
| /** |
| * Builds the title of the dialog window.<p> |
| * |
| * @param title the title String for the dialog window |
| * |
| * @return the HTML title String for the dialog window |
| */ |
| public String dialogHead(String title) { |
| return "<div class=\"dialoghead\" unselectable=\"on\">" + (title == null ? "" : title) + "</div>"; |
| } |
| |
| /** |
| * Returns the value of the title parameter, |
| * or null if this parameter was not provided.<p> |
| * |
| * This parameter is used to build the title |
| * of the dialog. It is a parameter so that the title |
| * can be passed to included elements.<p> |
| * |
| * @return the value of the title parameter |
| */ |
| public String getParamTitle(HttpServletRequest request) { |
| if (paramTitle == null) { |
| paramTitle = request.getParameter("title"); |
| } |
| return paramTitle != null ? paramTitle : ""; |
| } |
| |
| /** |
| * Returns all initialized parameters of the current workplace class |
| * as hidden field tags that can be inserted in a form.<p> |
| * |
| * @return all initialized parameters of the current workplace class |
| * as hidden field tags that can be inserted in a html form |
| */ |
| public String paramsAsHidden(HttpServletRequest request) { |
| return paramsAsHidden(request, null); |
| } |
| |
| /** |
| * Returns all initialized parameters of the current workplace class |
| * that are not in the given exclusion list as hidden field tags that can be inserted in a form.<p> |
| * |
| * @param excludes the parameters to exclude |
| * |
| * @return all initialized parameters of the current workplace class |
| * that are not in the given exclusion list as hidden field tags that can be inserted in a form |
| */ |
| public String paramsAsHidden(HttpServletRequest request, Collection<?> excludes) { |
| StringBuffer result = new StringBuffer(512); |
| Map<String, Object> params = paramValues(request); |
| Iterator<?> i = params.entrySet().iterator(); |
| while (i.hasNext()) { |
| Map.Entry entry = (Map.Entry)i.next(); |
| String param = (String)entry.getKey(); |
| if ((excludes == null) || (!excludes.contains(param))) { |
| result.append("<input type=\"hidden\" name=\""); |
| result.append(param); |
| result.append("\" value=\""); |
| String encoded = ReportEncoder.encode( |
| entry.getValue().toString(), |
| "UTF-8"); |
| result.append(encoded); |
| result.append("\">\n"); |
| } |
| } |
| |
| return result.toString(); |
| } |
| |
| /** |
| * Returns the values of all parameter methods of this workplace class instance.<p> |
| * |
| * @return the values of all parameter methods of this workplace class instance |
| */ |
| protected Map<String, Object> paramValues(HttpServletRequest request) { |
| List<Method> methods = paramGetMethods(); |
| Map<String, Object> map = new HashMap<String, Object>(methods.size()); |
| Iterator<Method> i = methods.iterator(); |
| while (i.hasNext()) { |
| Method m = (Method)i.next(); |
| Object o = null; |
| try { |
| o = m.invoke(this, new Object[0]); |
| } catch (InvocationTargetException ite) { |
| // can usually be ignored |
| } catch (IllegalAccessException eae) { |
| // can usually be ignored |
| } |
| if (o != null) { |
| map.put(m.getName().substring(8).toLowerCase(), o); |
| } |
| } |
| return map; |
| } |
| |
| /** |
| * Returns a list of all methods of the current class instance that |
| * start with "getParam" and have no parameters.<p> |
| * |
| * @return a list of all methods of the current class instance that |
| * start with "getParam" and have no parameters |
| */ |
| private List<Method> paramGetMethods() { |
| List<Method> list = new ArrayList<Method>(); |
| Method[] methods = this.getClass().getMethods(); |
| int length = methods.length; |
| for (int i = 0; i < length; i++) { |
| Method method = methods[i]; |
| if (method.getName().startsWith("getParam") && (method.getParameterTypes().length == 0)) { |
| // Debug.logInfo("getMethod: " + method.getName(), module); |
| list.add(method); |
| } |
| } |
| return list; |
| } |
| |
| /** |
| * Returns an optional introduction text to be displayed above the report output.<p> |
| * |
| * @return an optional introduction text |
| */ |
| public String reportIntroductionText() { |
| return ""; |
| } |
| |
| /** |
| * Returns an optional conclusion text to be displayed below the report output.<p> |
| * |
| * @return an optional conclusion text |
| */ |
| public String reportConclusionText() { |
| return ""; |
| } |
| |
| /** |
| * Returns the end html for the content area of the dialog window.<p> |
| * |
| * @return the end html for the content area of the dialog window |
| */ |
| public String dialogContentEnd() { |
| return dialogContent(HTML_END, null); |
| } |
| |
| /** |
| * Builds a button row with an "Ok" and a "Cancel" button.<p> |
| * |
| * This row is displayed when the first report is running.<p> |
| * |
| * @param okAttrs optional attributes for the ok button |
| * @param cancelAttrs optional attributes for the cancel button |
| * @return the button row |
| */ |
| public String dialogButtonsContinue(String okAttrs, String cancelAttrs) { |
| return dialogButtons(new int[] {BUTTON_OK, BUTTON_CANCEL}, new String[] { |
| okAttrs, |
| cancelAttrs}); |
| } |
| |
| /** |
| * Builds a button row with an "OK" and a "Cancel" button.<p> |
| * |
| * This row is used when a single report is running or after the first report has finished.<p> |
| * |
| * @param okAttrs optional attributes for the ok button |
| * @param cancelAttrs optional attributes for the cancel button |
| * @return the button row |
| */ |
| public String dialogButtonsOkCancel(HttpServletRequest request, String okAttrs, String cancelAttrs) { |
| if (Boolean.valueOf(getParamThreadHasNext(request)).booleanValue() |
| && ReportStringUtil.isNotEmpty(getParamReportContinueKey())) { |
| return dialogButtons(new int[] {BUTTON_OK, BUTTON_CANCEL}, new String[] { |
| okAttrs, |
| cancelAttrs}); |
| } |
| return dialogButtons(new int[] {BUTTON_OK}, new String[] {okAttrs}); |
| } |
| |
| /** |
| * Builds a button row with an "OK", a "Cancel" and a "Download" button.<p> |
| * |
| * This row is used when a single report is running or after the first report has finished.<p> |
| * |
| * @param okAttrs optional attributes for the ok button |
| * @param cancelAttrs optional attributes for the cancel button |
| * @param downloadAttrs optional attributes for the download button |
| * @return the button row |
| */ |
| public String dialogButtonsOkCancelDownload(HttpServletRequest request, String okAttrs, String cancelAttrs, String downloadAttrs) { |
| if (ReportStringUtil.isEmptyOrWhitespaceOnly(downloadAttrs)) { |
| downloadAttrs = ""; |
| } else { |
| downloadAttrs += " "; |
| } |
| if (Boolean.valueOf(getParamThreadHasNext(request)).booleanValue() |
| && ReportStringUtil.isNotEmpty(getParamReportContinueKey())) { |
| return dialogButtons(new int[] {BUTTON_OK, BUTTON_CANCEL, BUTTON_DOWNLOAD}, new String[] { |
| okAttrs, |
| cancelAttrs, |
| downloadAttrs + "onclick=\"downloadPricat(" + (sequenceNum > 0 ? sequenceNum : "") + ");\""}); |
| } |
| return dialogButtons(new int[] {BUTTON_OK, BUTTON_DOWNLOAD}, new String[] { |
| okAttrs, |
| downloadAttrs + "onclick=\"downloadPricat(" + (sequenceNum > 0 ? sequenceNum : "") + ");\""}); |
| } |
| |
| /** |
| * Builds the html for the button row under the dialog content area, including buttons.<p> |
| * |
| * @param buttons array of constants of which buttons to include in the row |
| * @param attributes array of Strings for additional button attributes |
| * |
| * @return the html for the button row under the dialog content area, including buttons |
| */ |
| public String dialogButtons(int[] buttons, String[] attributes) { |
| StringBuffer result = new StringBuffer(256); |
| result.append(dialogButtonRow(HTML_START)); |
| for (int i = 0; i < buttons.length; i++) { |
| dialogButtonsHtml(result, buttons[i], attributes[i]); |
| } |
| result.append(dialogButtonRow(HTML_END)); |
| return result.toString(); |
| } |
| |
| /** |
| * Builds the button row under the dialog content area without the buttons.<p> |
| * |
| * @param segment the HTML segment (START / END) |
| * |
| * @return the button row start / end segment |
| */ |
| public String dialogButtonRow(int segment) { |
| if (segment == HTML_START) { |
| return "<!-- button row start -->\n<div class=\"dialogbuttons\" unselectable=\"on\">\n"; |
| } else { |
| return "</div>\n<!-- button row end -->\n"; |
| } |
| } |
| |
| /** |
| * Renders the HTML for a single input button of a specified type.<p> |
| * |
| * @param result a string buffer where the rendered HTML gets appended to |
| * @param button a integer key to identify the button |
| * @param attribute an optional string with possible tag attributes, or null |
| */ |
| protected void dialogButtonsHtml(StringBuffer result, int button, String attribute) { |
| attribute = appendDelimiter(attribute); |
| switch (button) { |
| case BUTTON_OK: |
| result.append("<input name=\"ok\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_OK", getLocale()) + "\""); |
| if (attribute.toLowerCase().indexOf("onclick") == -1) { |
| result.append(" type=\"submit\""); |
| } else { |
| result.append(" type=\"button\""); |
| } |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| case BUTTON_CANCEL: |
| result.append("<input name=\"cancel\" type=\"button\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_CANCEL", getLocale()) + "\""); |
| if (attribute.toLowerCase().indexOf("onclick") == -1) { |
| result.append(" onclick=\"submitAction('" + DIALOG_CANCEL + "', form);\""); |
| } |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| case BUTTON_EDIT: |
| result.append("<input name=\"ok\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_EDIT", getLocale()) + "\""); |
| if (attribute.toLowerCase().indexOf("onclick") == -1) { |
| result.append(" type=\"submit\""); |
| } else { |
| result.append(" type=\"button\""); |
| } |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| case BUTTON_DISCARD: |
| result.append("<input name=\"cancel\" type=\"button\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_DISCARD", getLocale()) + "\""); |
| if (attribute.toLowerCase().indexOf("onclick") == -1) { |
| result.append(" onclick=\"submitAction('" + DIALOG_CANCEL + "', form);\""); |
| } |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| case BUTTON_CLOSE: |
| result.append("<input name=\"close\" type=\"button\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_CLOSE", getLocale()) + "\""); |
| if (attribute.toLowerCase().indexOf("onclick") == -1) { |
| result.append(" onclick=\"submitAction('" + DIALOG_CANCEL + "', form);\""); |
| } |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| case BUTTON_ADVANCED: |
| result.append("<input name=\"advanced\" type=\"button\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_ADVANCE", getLocale()) + "\""); |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| case BUTTON_SET: |
| result.append("<input name=\"set\" type=\"button\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_SET", getLocale()) + "\""); |
| if (attribute.toLowerCase().indexOf("onclick") == -1) { |
| result.append(" onclick=\"submitAction('" + DIALOG_SET + "', form);\""); |
| } |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| case BUTTON_BACK: |
| result.append("<input name=\"set\" type=\"button\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_BACK", getLocale()) + "\""); |
| if (attribute.toLowerCase().indexOf("onclick") == -1) { |
| result.append(" onclick=\"submitAction('" + DIALOG_BACK + "', form);\""); |
| } |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| case BUTTON_CONTINUE: |
| result.append("<input name=\"set\" type=\"button\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_CONTINUE", getLocale()) + "\""); |
| if (attribute.toLowerCase().indexOf("onclick") == -1) { |
| result.append(" onclick=\"submitAction('" + DIALOG_CONTINUE + "', form);\""); |
| } |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| case BUTTON_DETAILS: |
| result.append("<input name=\"details\" type=\"button\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_DETAIL", getLocale()) + "\""); |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| case BUTTON_DOWNLOAD: |
| result.append("<input name=\"download\" type=\"button\" value=\""); |
| result.append(UtilProperties.getMessage(resource, "DIALOG_BUTTON_DOWNLOAD", getLocale()) + "\""); |
| result.append(" class=\"dialogbutton\""); |
| result.append(attribute); |
| result.append(">\n"); |
| break; |
| default: |
| // not a valid button code, just insert a warning in the HTML |
| result.append("<!-- invalid button code: "); |
| result.append(button); |
| result.append(" -->\n"); |
| } |
| } |
| |
| /** |
| * Appends a space char. between tag attributes.<p> |
| * |
| * @param attribute a tag attribute |
| * |
| * @return the tag attribute with a leading space char |
| */ |
| protected String appendDelimiter(String attribute) { |
| if (ReportStringUtil.isNotEmpty(attribute)) { |
| if (!attribute.startsWith(" ")) { |
| // add a delimiter space between the beginning button HTML and the button tag attributes |
| return " " + attribute; |
| } else { |
| return attribute; |
| } |
| } |
| return ""; |
| } |
| |
| /** |
| * Returns true if the dialog operation has to be performed on multiple resources.<p> |
| * |
| * @return true if the dialog operation has to be performed on multiple resources, otherwise false |
| */ |
| public boolean isMultiOperation(HttpServletRequest request) { |
| return (getResourceList(request).size() > 1); |
| } |
| |
| /** |
| * Returns the resources that are defined for the dialog operation. |
| * |
| * For single resource operations, the list contains one item: the resource name found |
| * in the request parameter value of the "resource" parameter. |
| * |
| * @return the resources that are defined for the dialog operation |
| */ |
| public List<String> getResourceList(HttpServletRequest request) { |
| if (resourceList == null) { |
| // use lazy initializing |
| if (getParamResourcelist(request) != null) { |
| // found the resourcelist parameter |
| resourceList = StringUtil.split(getParamResourcelist(request), DELIMITER_RESOURCES); |
| Collections.sort(resourceList); |
| } else { |
| // this is a single resource operation, create list containing the resource name |
| resourceList = new ArrayList<String>(1); |
| String resource = getParamResource(request); |
| if (ReportStringUtil.isNotEmptyOrWhitespaceOnly(resource)) { |
| resourceList.add(resource); |
| } else { |
| resourceList.add(""); |
| } |
| } |
| } |
| return resourceList; |
| } |
| |
| /** |
| * Returns the value of the resource list parameter, or null if the parameter is not provided.<p> |
| * |
| * This parameter selects the resources to perform operations on.<p> |
| * |
| * @return the value of the resource list parameter or null, if the parameter is not provided |
| */ |
| public String getParamResourcelist(HttpServletRequest request) { |
| if (ReportStringUtil.isNotEmpty(paramResourcelist) && !"null".equals(paramResourcelist)) { |
| return paramResourcelist; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the value of the file parameter, |
| * or null if this parameter was not provided.<p> |
| * |
| * The file parameter selects the file on which the dialog action |
| * is to be performed.<p> |
| * |
| * @return the value of the file parameter |
| */ |
| public String getParamResource(HttpServletRequest request) { |
| paramResource = request.getParameter("resource"); |
| if ((paramResource != null) && !"null".equals(paramResource)) { |
| return paramResource; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns if the workplace must be refreshed.<p> |
| * |
| * @return <code>"true"</code> if the workplace must be refreshed. |
| */ |
| public String getParamRefreshWorkplace() { |
| return paramRefreshWorkplace; |
| } |
| |
| /** |
| * Returns the key name which contains the localized message for the continue checkbox.<p> |
| * |
| * @return the key name which contains the localized message for the continue checkbox |
| */ |
| public String getParamReportContinueKey() { |
| if (paramReportContinueKey == null) { |
| paramReportContinueKey = ""; |
| } |
| return paramReportContinueKey; |
| } |
| |
| /** |
| * Returns the value of the resourcelist parameter in form of a String separated |
| * with {@link #DELIMITER_RESOURCES}, or the value of the resource parameter if the |
| * first parameter is not provided (no multiple choice has been done.<p> |
| * |
| * This may be used for jsps as value for the parameter for resources {@link #PARAM_RESOURCELIST}.<p> |
| * |
| * @return the value of the resourcelist parameter or null, if the parameter is not provided |
| */ |
| public String getResourceListAsParam(HttpServletRequest request) { |
| String result = getParamResourcelist(request); |
| if (ReportStringUtil.isEmptyOrWhitespaceOnly(result)) { |
| result = getParamResource(request); |
| } |
| return result; |
| } |
| |
| /** |
| * Returns the end html for the outer dialog window border.<p> |
| * |
| * @return the end html for the outer dialog window border |
| */ |
| public String dialogEnd() { |
| return dialog(HTML_END, null); |
| } |
| |
| /** |
| * Returns the http URI of the current dialog, to be used |
| * as value for the "action" attribute of a html form.<p> |
| * |
| * This URI is the real one.<p> |
| * |
| * @return the http URI of the current dialog |
| */ |
| public String getDialogRealUri(HttpServletRequest request) { |
| return String.valueOf(request.getAttribute(DIALOG_URI)); |
| } |
| |
| /** |
| * Set the report form uri. |
| * |
| * @param request |
| * @param formUri |
| */ |
| public void setFormRealUri(HttpServletRequest request, String formUri) { |
| request.setAttribute(FORM_URI, formUri); |
| } |
| |
| /** |
| * Get the report form uri. |
| * |
| * @param request |
| * @return |
| */ |
| public String getFormRealUri(HttpServletRequest request) { |
| return (String) request.getAttribute(FORM_URI); |
| } |
| |
| public void addLogFile(String logFileName) { |
| if (logFile == null || logFileOutputStream == null) { |
| this.logFileName = logFileName; |
| logFile = FileUtil.getFile(logFileName); |
| try { |
| logFileOutputStream = new FileOutputStream(logFile); |
| } catch (FileNotFoundException e) { |
| // do nothing |
| } |
| } |
| } |
| |
| public String closeLogFile() { |
| if (logFileOutputStream != null) { |
| try { |
| logFileOutputStream.flush(); |
| } catch (IOException e) { |
| // do nothing |
| } finally { |
| if (logFileOutputStream != null) { |
| try { |
| logFileOutputStream.close(); |
| } catch (IOException e) { |
| // do nothing |
| Debug.logError(e, HtmlReport.module); |
| } |
| } |
| } |
| } |
| return logFileName; |
| } |
| |
| public String getLogFileName() { |
| return logFileName; |
| } |
| |
| public long getSequenceNum() { |
| return sequenceNum; |
| } |
| |
| public void setSequenceNum(long sequenceNum) { |
| this.sequenceNum = sequenceNum; |
| } |
| } |
