package org.apache.beehive.netui.tags;
import org.apache.beehive.netui.util.internal.InternalStringBuilder;
import org.apache.beehive.netui.util.Bundle;
import org.apache.beehive.netui.util.logging.Logger;
import org.apache.struts.util.ResponseUtils;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.JspTag;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.List;
public class ErrorHandling
{
/**
* static flag indicating if we are reporting errors in-page or throwing JspExceptions.
*/
private static boolean reportErrorInPage = true;
private static final Logger logger = Logger.getInstance(ErrorHandling.class);
private List _errors;
/**
* This will report an error from a tag. The error will
* contain a message. If error reporting is turned off,
* the message will be returned and the caller should throw
* a JspException to report the error.
* @param message - the message to register with the error
* @throws javax.servlet.jsp.JspException - if in-page error reporting is turned off this method will always
* throw a JspException.
*/
public void registerTagError(String message, String tagName, JspTag tag, Throwable e)
throws JspException
{
assert (message != null) : "parameter 'message' must not be null.";
// add the error to the list of errors
if (_errors == null)
_errors = new ArrayList();
TagErrorInfo tei = new TagErrorInfo();
tei.tagType = tagName;
tei.message = message;
_errors.add(tei);
IErrorReporter er = getErrorReporter(tag);
if (er == null) {
tei.errorNo = -1;
if (!reportErrorInPage) {
String s = Bundle.getString("Tags_NoInPageErrorReporting", new Object[]{message});
if (e == null)
logger.error(s);
else
logger.error(s, e);
//localRelease();
throw new JspException(message);
}
return;
}
// add the error to the ErrorReporter tag
er.addError(tei);
assert (tei.errorNo > 0);
if (!reportErrorInPage) {
String s = Bundle.getString("Tags_NoInPageErrorReporting", new Object[]{message});
if (e == null)
logger.error(s);
else
logger.error(s, e);
//localRelease();
throw new JspException(s);
}
return;
}
/**
* This method will add an error to the errors begin tracked by the tag. After the first time this method
* is called, <code>hasErrors</code> will return true.
* @param error The <code>EvalErrorInfo</code> describing the error.
*/
public void registerTagError(AbstractPageError error, JspTag tag)
throws JspException
{
assert (error != null);
// add the error to the list of errors
if (_errors == null)
_errors = new ArrayList();
_errors.add(error);
IErrorReporter er = getErrorReporter(tag);
if (er == null) {
error.errorNo = -1;
return;
}
// add the error to the ErrorReporter tag
er.addError(error);
assert (error.errorNo > 0);
}
/**
* This method will return <code>true</code> if there have been any errors registered on this
* tag. Otherwise it returns <code>false</code>
* @return <code>true</code> if errors have been reported on this tag.
* @see #registerTagError
*/
public boolean hasErrors()
{
return (_errors != null);
}
/**
* This method will write out the <code>String</code> returned by <code>getErrorsReport</code> to the
* response output stream.
* @throws JspException if <code>write</code> throws an exception.
* @see #getErrorsReport
*/
public void reportErrors(Writer writer, String tagName)
throws JspException
{
try {
writer.write(getErrorsReport(tagName));
}
catch (IOException e) {
JspException jspException = new JspException(e.getMessage(), e);
jspException.initCause(e);
throw jspException;
}
}
public String getInlineError(String tagName)
{
if (isInlineErrors()) {
AbstractPageError info = (AbstractPageError) _errors.get(0);
return getInlineError(info, tagName);
}
return null;
}
/**
* This method will return a <code>String<code> that represents all of the errors that were
* registered for the tag. This method assumes that there are errors in the tag and asserts
* this is true. Code will typically call <code>hasErrors</code> before calling this method.
* @return A <code>String</code> that contains all of the errors registered on this tag.
* @see #registerTagError
*/
public String getErrorsReport(String tagName)
{
assert _errors != null;
assert _errors.size() > 0;
int cnt = _errors.size();
InternalStringBuilder sb = new InternalStringBuilder(128);
// check the first error to see if we are reporting errors at the end
AbstractPageError info = (AbstractPageError) _errors.get(0);
if (isInlineErrors()) {
String s = getInlineError(info, tagName);
return s;
}
// create the errors
String s;
s = Bundle.getString("Tag_Header",
new Object[]{tagName, Integer.toString(cnt)});
sb.append(s);
Object[] args = new Object[4];
for (int i = 0; i < cnt; i++) {
Object o = _errors.get(i);
if (o instanceof EvalErrorInfo) {
EvalErrorInfo e = (EvalErrorInfo) o;
assert info != null;
args[0] = Bundle.getString("Expression_Error");
args[1] = e.attr;
args[2] = e.expression;
args[3] = e.evalExcp.getMessage();
s = Bundle.getString("Expression_Error_Line", args);
}
else if (o instanceof TagErrorInfo) {
TagErrorInfo e = (TagErrorInfo) o;
assert info != null;
args[0] = Bundle.getString("Tag_Error");
args[1] = e.message;
s = Bundle.getString("Tag_Error_Line", args);
}
sb.append(s);
}
s = Bundle.getString("Tag_Footer");
sb.append(s);
return sb.toString();
}
/**
* This method get the current errors and write the formated output
* @param sb
*/
public static void reportCollectedErrors(InternalStringBuilder sb, JspTag tag)
{
IErrorReporter er = getErrorReporter(tag);
if (er == null)
return;
assert (sb != null);
ArrayList errors = er.returnErrors();
if (errors == null || errors.size() == 0)
return;
assert(errors.size() > 0);
String s;
// write the error header
s = Bundle.getString("Footer_Error_Header");
sb.append(s);
int cnt = errors.size();
Object[] args = new Object[5];
for (int i = 0; i < cnt; i++) {
Object o = errors.get(i);
assert (o != null);
if (o instanceof EvalErrorInfo) {
EvalErrorInfo err = (EvalErrorInfo) o;
args[0] = Integer.toString(err.errorNo);
args[1] = err.tagType;
args[2] = err.attr;
args[3] = err.expression;
args[4] = err.evalExcp.getMessage();
s = Bundle.getString("Footer_Error_Expr_Body", args);
sb.append(s);
}
else if (o instanceof TagErrorInfo) {
TagErrorInfo tei = (TagErrorInfo) o;
args[0] = Integer.toString(tei.errorNo);
args[1] = tei.tagType;
args[2] = tei.message;
s = Bundle.getString("Footer_Error_Tag_Body", args);
sb.append(s);
}
}
// write the error footer
s = Bundle.getString("Footer_Error_Footer");
sb.append(s);
}
/**
* This method get the current errors and write the formated output
* @param pc
*/
public static void reportCollectedErrors(PageContext pc, JspTag tag)
{
IErrorReporter er = getErrorReporter(tag);
if (er == null)
return;
assert (pc != null);
ArrayList errors = er.returnErrors();
if (errors == null || errors.size() == 0)
return;
assert(errors.size() > 0);
String s;
// write the error header
s = Bundle.getString("Footer_Error_Header");
write(pc, s);
int cnt = errors.size();
Object[] args = new Object[5];
for (int i = 0; i < cnt; i++) {
Object o = errors.get(i);
assert (o != null);
if (o instanceof EvalErrorInfo) {
EvalErrorInfo err = (EvalErrorInfo) o;
args[0] = Integer.toString(err.errorNo);
args[1] = err.tagType;
args[2] = err.attr;
args[3] = err.expression;
args[4] = err.evalExcp.getMessage();
s = Bundle.getString("Footer_Error_Expr_Body", args);
write(pc, s);
}
else if (o instanceof TagErrorInfo) {
TagErrorInfo tei = (TagErrorInfo) o;
args[0] = Integer.toString(tei.errorNo);
args[1] = tei.tagType;
args[2] = tei.message;
s = Bundle.getString("Footer_Error_Tag_Body", args);
write(pc, s);
}
}
// write the error footer
s = Bundle.getString("Footer_Error_Footer");
write(pc, s);
}
private boolean isInlineErrors()
{
AbstractPageError info = (AbstractPageError) _errors.get(0);
return (info.errorNo > 0);
}
private String getInlineError(AbstractPageError info, String tagName)
{
String s;
if (info instanceof EvalErrorInfo) {
s = Bundle.getString("Expression_Error");
s = Bundle.getString("Inline_error",
new Object[]{
s,
Integer.toString(info.errorNo),
tagName,
});
}
else if (info instanceof TagErrorInfo) {
s = Bundle.getString("Tag_Error");
s = Bundle.getString("Inline_error",
new Object[]{
s,
Integer.toString(info.errorNo),
tagName,
});
}
else {
s = null;
assert true : "Unhandled type";
}
return s;
}
/**
* This method will return the first <code>ErrorReporter</code> in the parental chain of the
* tag. Searching starts with this tag.
* @return an <code>ErrorReporter</code> if one is found in the parental chain, otherwise null.
*/
private static IErrorReporter getErrorReporter(JspTag tag)
{
if (tag instanceof IErrorReporter && ((IErrorReporter) tag).isReporting())
return (IErrorReporter) tag;
// check to see if this tag has is an ErrorReporter or has an ErrorReporter as a parent
IErrorReporter er = (IErrorReporter) SimpleTagSupport.findAncestorWithClass(tag, IErrorReporter.class);
while (er != null) {
if (er.isReporting())
return er;
er = (IErrorReporter) SimpleTagSupport.findAncestorWithClass((JspTag) er, IErrorReporter.class);
}
return null;
}
private static final void write(PageContext pc, String string)
{
try {
ResponseUtils.write(pc, string);
}
catch (JspException e) {
logger.error(Bundle.getString("Tags_WriteException"), e);
}
}
}