private String filterNew(InvocationChain chain) throws Exception {
Action action = chain.getAction();
super.setInput(action.getInput());
action.setInput(this);
this.action.set(action);
return chain.invoke();
}
public String filter(InvocationChain chain) throws Exception {
if (name != null) {
// new filter! (the old one is deprecated, should use
// OutjectionFilter instead!)
return filterNew(chain);
}
String result = chain.invoke();
Action action = chain.getAction();
Output output = action.getOutput();
boolean isModelDriven = false;
boolean isPojoAction = false;
if (action instanceof ModelDriven) {
isModelDriven = true;
} else if (action instanceof PojoAction) {
isPojoAction = true;
}
Method[] methods = null;
if (isModelDriven) {
ModelDriven md = (ModelDriven) action;
methods = md.getModel().getClass().getMethods();
} else if (isPojoAction) {
PojoAction pa = (PojoAction) action;
methods = pa.getPojo().getClass().getMethods();
} else {
methods = action.getClass().getDeclaredMethods();
}
for (int i = 0; i < methods.length; i++) {
String name = methods[i].getName();
if (name.length() > 3
&& name.startsWith("get")
&& methods[i].getParameterTypes().length == 0) {
if (name.equals("getClass")) continue;
try {
methods[i].setAccessible(true);
Object value = null;
if (isModelDriven) {
ModelDriven md = (ModelDriven) action;
value = methods[i].invoke(md.getModel(), (Object[]) null);
} else if (isPojoAction) {
PojoAction pa = (PojoAction) action;
value = methods[i].invoke(pa.getPojo(), (Object[]) null);
} else {
value = methods[i].invoke(action, new Object[0]);
}
output.setValue(adjustName(name), value);
} catch (Exception e) {
System.err.println("Error calling method in OutputFilter: " + name);
e.printStackTrace();
}
}
}
return result;
}
/**
* Filters the action, begining a transaction before the action's execution and commiting or
* rollbacking the trasaction after the action's exection depending on the result.
*/
public String filter(InvocationChain chain) throws Exception {
Action action = chain.getAction();
Input input = action.getInput();
if (onlyPost) {
// only execute for POST...
String method = input.getProperty("method");
boolean isPost = method != null && method.equalsIgnoreCase("post");
if (!isPost) return chain.invoke();
}
Transaction transaction = (Transaction) input.getValue(transactionKey);
// special case: two actions with transaction filter being called in a chain:
/*
* if (transaction != null && (transaction.wasCommited() || transaction.wasRolledBack())) {
*
* input.removeValue(transactionKey);
*
* transaction = (Transaction) input.getValue(transactionKey); }
*
* // by Sergio: You can now freely re-use transaction (since 1.16)
*/
if (transaction == null) {
Debug.log(NAME, "Transaction was NULL inside TransactionFilter!!!");
throw new FilterException(
"Cannot find transaction in action's " + "input with the given key: " + transactionKey);
}
try {
Debug.log(NAME, "Beginning transaction...");
transaction.begin();
Debug.log(NAME, "Transaction was begun! Will invoke action...");
String result = chain.invoke();
boolean shouldRollback = resultsForRollback.contains(result);
boolean shouldCommit = resultsForCommit.contains(result);
if (shouldCommit || (!shouldCommit && !shouldRollback)) {
Debug.log(NAME, "Result was ok! Will commit the transaction...", "Result=", result);
transaction.commit();
Debug.log(NAME, "Transaction was committed!");
} else {
Debug.log(NAME, "Result was not ok! Will rollback the transaction...", "Result=", result);
transaction.rollback();
Debug.log(NAME, "Transaction was rolled back!");
}
return result;
} catch (Exception e) {
e.printStackTrace();
// rollbacks the transcion if any error occours.
Debug.log(
NAME,
"An exception was thrown while executing action! Will try to rollback...",
"msg=",
e.getMessage());
if (transaction.isActive()) {
transaction.rollback();
Debug.log(NAME, "Transaction was rolled back!");
}
throw e;
}
}