/*
    * Copyright (c) 2001 - 2005 ivata limited.
    * All rights reserved.
    * -----------------------------------------------------------------------------
    * ivata masks may be redistributed under the GNU General Public
    * License as published by the Free Software Foundation;
    * version 2 of the License.
    *
    * These programs are free software; you can redistribute them and/or
   * modify them under the terms of the GNU General Public License
   * as published by the Free Software Foundation; version 2 of the License.
   *
   * These programs are distributed in the hope that they will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   *
   * See the GNU General Public License in the file LICENSE.txt for more
   * details.
   *
   * If you would like a copy of the GNU General Public License write to
   *
   * Free Software Foundation, Inc.
   * 59 Temple Place - Suite 330
   * Boston, MA 02111-1307, USA.
   *
   *
   * To arrange commercial support and licensing, contact ivata at
   *                  http://www.ivata.com/contact.jsp
   * -----------------------------------------------------------------------------
   * $Log: MaskAction.java,v $
   * Revision 1.12  2005/05/01 08:54:50  colinmacleod
   * Final changes for 0.6.1.
   *
   * Revision 1.11  2005/04/29 16:34:13  colinmacleod
   * Cleared deleteWarn after it is used the first
   * time.
   *
   * Revision 1.10  2005/04/09 18:04:18  colinmacleod
   * Changed copyright text to GPL v2 explicitly.
   *
   * Revision 1.9  2005/03/10 10:41:09  colinmacleod
   * Added default forwards.
   *
   * Revision 1.8  2005/01/19 13:14:02  colinmacleod
   * Renamed CausedByException to SystemException.
   *
   * Revision 1.7  2005/01/07 13:11:03  colinmacleod
   * Corrected setting of default list mask.
   * (It was set to the input mask instead of list.)
   *
   * Revision 1.6  2005/01/07 08:43:30  colinmacleod
   * Added missing javadoc for getAuthenticator and getMaskFactory.
   *
   * Revision 1.5  2005/01/07 08:08:24  colinmacleod
   * Moved up a version number.
   * Changed copyright notices to 2005.
   * Updated the documentation:
   *   - started working on multiproject:site docu.
   *   - changed the logo.
   * Added checkstyle and fixed LOADS of style issues.
   * Added separate thirdparty subproject.
   * Added struts (in web), util and webgui (in webtheme) from ivata op.
   *
   * Revision 1.4  2004/12/23 21:28:32  colinmacleod
   * Modifications to add ivata op compatibility.
   *
   * Revision 1.3  2004/11/12 15:10:42  colinmacleod
   * Moved persistence classes from ivata op as a replacement for
   * ValueObjectLocator.
   *
   * Revision 1.2  2004/05/18 22:06:37  colinmacleod
   * Fixed isCancelled by re-implementing it.
   *
   * Revision 1.1.1.1  2004/05/16 20:40:33  colinmacleod
   * Ready for 0.1 release
   *
   * Revision 1.3  2004/03/21 21:16:08  colinmacleod
   * Shortened name to ivata op.
   *
   * Revision 1.2  2004/02/01 22:00:33  colinmacleod
   * Added full names to author tags
   *
   * Revision 1.1.1.1  2004/01/27 20:57:55  colinmacleod
   * Moved ivata op to SourceForge.
   *
   * Revision 1.3  2003/11/13 16:03:16  jano
   * Worked on bugs in login stage - basic fixes so application is running.
   *
   * Revision 1.2  2003/10/17 12:36:13  jano
   * fixing problems with building
   * converting intranet -> portal
   * Eclipse building
   *
   * Revision 1.1.1.1  2003/10/13 20:50:01  colin
   * Restructured portal into subprojects
   *
   * Revision 1.11  2003/08/14 08:15:38  peter
   * getRemote updated
   *
  * Revision 1.10  2003/08/04 11:38:58  peter
  * added getRemote, re-added flushCache
  *
  * Revision 1.9  2003/06/10 10:29:06  peter
  * flushing automatically prefixes the pattern given with context path
  *
  * Revision 1.8  2003/06/09 06:17:06  peter
  * added flushCache method
  *
  * Revision 1.7  2003/03/04 00:25:04  colin
  * added execute after clear, with a newly initialized form
  *
  * Revision 1.6  2003/02/24 19:08:16  colin
  * *** empty log message ***
  *
  * Revision 1.5  2003/02/18 11:12:08  colin
  * made more flexible by using PropertyUtils - now works with
  * DynaForms too
  *
  * Revision 1.4  2003/02/04 17:37:37  colin
  * new interface
  * added onConfirm, onDelete and clear
  *
  * Revision 1.3  2003/01/27 08:35:42  colin
  * simplified login procedure
  *
  * Revision 1.4  2003/01/18 20:50:26  colin
  * extended PortalAction and consolidated login checking
  * (userName in session?)
  * implemented JavaScript checking at login and help
  * functionality
  *
  * Revision 1.2  2003/01/10 10:34:13  colin
  * added drive.cat, drive.sub
  *
  * Revision 1.1  2002/11/12 12:01:57  colin
  * new business package incorporates business logic
  *
  * Revision 1.1  2002/11/12 10:38:11  colin
  * first version. doesn't do much yet - just initializes the
  * logger.
  * -----------------------------------------------------------------------------
  */
 package com.ivata.mask.web.struts;
 import java.lang.reflect.InvocationTargetException;
 
 import javax.naming.OperationNotSupportedException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import org.apache.commons.beanutils.PropertyUtils;
 import org.apache.log4j.Logger;
 import org.apache.struts.action.Action;
 import org.apache.struts.action.ActionErrors;
 import org.apache.struts.action.ActionForm;
 import org.apache.struts.action.ActionForward;
 import org.apache.struts.action.ActionMapping;
 import org.apache.struts.action.ActionMessages;
 import org.apache.struts.taglib.html.Constants;
 import com.ivata.mask.MaskFactory;
 import com.ivata.mask.util.SystemException;
 import com.ivata.mask.util.StringHandling;
 /***
  * <p>
  * Every <code>Action</code> in the system derives from this class, making it
  * possible to centralize logging instantiation, and check we have a valid
  * intranet session.
  * </p>
  *
  * @since ivata masks 0.4 (2002-11-10)
  * @author Colin MacLeod
  * <a href='mailto:colin.macleod@ivata.com'>colin.macleod@ivata.com</a>
  * @version $Revision: 1.12 $
  */
 public abstract class MaskAction extends Action {
     /***
      * Request attribute flag which indicates we have performed the
      * cancellation.
      */
     private static final String CANCEL_COMPLETE = "MASK_CANEL_COMPLETE";
     /***
      * <p>
      * This log provides tracing and debugging information.
      * </p>
      */
     private static Logger logger = Logger.getLogger(MaskAction.class);
     /***
      * <p>
      * This mask authenticator will be used to confirm whether or not the user
      * should be allowed to continue.
      * </p>
      */
     private MaskAuthenticator authenticator;
     /***
      * <p>
      * Set to <code>true</code> by <code>LoginAction</code> to indicate the
      * user name should not be checked.
      * </p>
      */
     private boolean login = false;
     /***
      * <p>
      * This factory is needed to access the masks and groups of masks.
      * </p>
      */
     private MaskFactory maskFactory;
     /***
      * <p>
      * Construct a mask action, with the given authenticator.
      * </p>
      *
      * @param maskFactoryParam
      *            This factory is needed to access the masks and groups of
      *            masks.
      * @param authenticatorParam
      *            used to confirm whether or not the user should be allowed to
      *            continue, in the <code>execute</code> method.
      */
     public MaskAction(final MaskFactory maskFactoryParam,
             final MaskAuthenticator authenticatorParam) {
         this.maskFactory = maskFactoryParam;
         this.authenticator = authenticatorParam;
     }
     /***
      * <p>
      * Called when the clear button is pressed, or after an ok or delete button,
      * where the session should be restored to its default state.
      * </p>
      *
      * @param mapping
      *            The ActionMapping used to select this instance.
      * @param errors
      *            valid errors object to append errors to. If there are any
      *            errors, the action will return to the input.
      * @param form
      *            optional ActionForm bean for this request (if any)
      * @param request
      *            non-HTTP request we are processing
      * @param response
      *            The non-HTTP response we are creating
      * @param session
      *            returned from the <code>request</code> parameter.
      * @throws SystemException
      *             if there is any problem which prevents processing. It will
      *             result in the webapp being forwarded to the standard error
      *             page.
      */
     public void clear(final ActionMapping mapping, final ActionErrors errors,
             final ActionForm form, final HttpServletRequest request,
             final HttpServletResponse response, final HttpSession session)
             throws SystemException {
         if (form instanceof MaskForm) {
             MaskForm maskForm = (MaskForm) form;
             try {
                 maskForm.clear();
             } catch (OperationNotSupportedException e) {
                 throw new SystemException(e);
             }
         }
     }
     /***
      * <p>
      * Called from the other <code>execute</code> method, this can be
      * overridden by each subclass to provide the <i>ivata </i>-specific
      * processing required.
      * </p>
      *
      * @param mapping
      *            The ActionMapping used to select this instance.
      * @param errors
      *            valid errors object to append errors to. If there are any
      *            errors, the action will return to the input.
      * @param form
      *            optional ActionForm bean for this request (if any)
      * @param request
      *            non-HTTP request we are processing
      * @param response
      *            The non-HTTP response we are creating
      * @param session
      *            returned from the <code>request</code> parameter.
      * @throws SystemException
      *             if there is any problem which prevents processing. It will
      *             result in the webapp being forwarded to the standard error
      *             page.
      * @return this method returns the string used to identify the correct
      *         <strong>Struts </strong> <code>ActionForward</code> which
      *         should follow this page, or <code>null</code> if it should
      *         return to the input.
      */
     public String execute(final ActionMapping mapping,
             final ActionErrors errors, final ActionForm form,
             final HttpServletRequest request,
             final HttpServletResponse response, final HttpSession session)
             throws SystemException {
         // default implementation just does nothing
         return null;
     }
     /***
      * <p>
      * Generic method called by the <strong>Struts </strong> interface.
      * </p>
      *
      * <p>
      * Process the specified HTTP request, and create the corresponding HTTP
      * response. Return an {@link ActionForward}instance describing where and
      * how control should be forwarded, or <code>null</code> if the response
      * has already been completed.
      * </p>
      *
      * @param mapping
      *            The ActionMapping used to select this instance
      * @param form
      *            The optional ActionForm bean for this request (if any)
      * @param request
      *            The non-HTTP request we are processing
      * @param response
      *            The non-HTTP response we are creating
      * @exception Exception
      *                if the application business logic throws an exception
      * @return this method returns a <code>"success"</code>
      * <code>ActionForward</code>
      *         if the compose session is cancelled or successfully sent,
      *         otherwise a <code>"failure"</code>
      * <code>ActionForward</code>.
      */
     public ActionForward execute(final ActionMapping mapping,
             final ActionForm form, final HttpServletRequest request,
             final HttpServletResponse response) throws Exception {
         // first get the session - we'll need that everywhere :-)
         HttpSession session = request.getSession();
         // if this isn't the login screen and we're missing security session
         // get out now
         String authenticateForward = authenticator.authenticate(session, login);
         if (authenticateForward != null) {
             logger.info("Authenticator for class " + getClass().getName()
                     + " -> forwarding to '" + authenticateForward + "'.");
             return mapping.findForward(authenticateForward);
         }
         try {
             String forward = null;
             ActionErrors errors = new ActionErrors();
             // in the following sections, if there is no such method, we just
             // ignore it - maybe we don't need this button in a DynaForm
             String apply = getFromRequestOrForm("apply", request, form);
             String clear = getFromRequestOrForm("clear", request, form);
             String deleteConfirm = getFromRequestOrForm("deleteConfirm",
                     request, form);
             String deleteWarn = getFromRequestOrForm("deleteWarn", request,
                     form);
             String ok = getFromRequestOrForm("ok", request, form);
             String defaultForwardApply = getFromRequestOrForm(
                     "defaultForwardApply",
                     request, form, "apply");
             String defaultForwardDelete =
                 getFromRequestOrForm("defaultForwardDelete",
                     request, form, "delete");
             String defaultForwardOk = getFromRequestOrForm("defaultForwardOk",
                     request, form, "ok");
 
             // Was this transaction cancelled?
             if (isCancelled(request)) {
                 if (logger.isInfoEnabled()) {
                     logger.info("MaskAction [" + this.getClass().getName()
                             + "] amendment was cancelled.");
                 }
                 clear(mapping, errors, form, request, response, session);
                 request.setAttribute(CANCEL_COMPLETE, "true");
                 return mapping.findForward("cancel");
             }
             // if the person is being warned about delete, just go back
             if (!StringHandling.isNullOrEmpty(deleteWarn)) {
                 try {
                     PropertyUtils.setProperty(form, "deleteWarn", "");
                 } catch (Exception e) {
                     if (logger.isDebugEnabled()) {
                         logger.debug("Exception re-setting deleteWarn.", e);
                     }
                 }
                 return mapping.getInputForward();
             }
             // first was the clear button pressed?
             boolean isOk;
             if (!StringHandling.isNullOrEmpty(clear)) {
                 clear(mapping, errors, form, request, response, session);
                 if (form instanceof MaskForm) {
                     DialogForm dialogForm = (DialogForm) form;
                     dialogForm.clear();
                 }
                 forward = execute(mapping, errors, form, request, response,
                         session);
                 // was the delete confirmation button pressed?
             } else if (!StringHandling.isNullOrEmpty(deleteConfirm)) {
                 forward = onDelete(mapping, errors, form, request, response,
                         session, defaultForwardDelete);
                 if (forward == null) {
                     // this stops us going round in circles!
                     PropertyUtils.setProperty(form, "delete", "");
                 } else {
                     clear(mapping, errors, form, request, response, session);
                 }
                 // was ok or apply pressed?
             } else if ((isOk = !StringHandling.isNullOrEmpty(ok))
                     || !StringHandling.isNullOrEmpty(apply)) {
                 String defaultForward;
                 if (isOk) {
                     defaultForward = defaultForwardOk;
                 } else {
                     defaultForward = defaultForwardApply;
                 }
                 forward = onConfirm(mapping, errors, form, request, response,
                         session, defaultForward);
                 if (forward == null) {
                     // this stops us going round in circles!
                     PropertyUtils.setProperty(form, "ok", "");
                     PropertyUtils.setProperty(form, "apply", "");
                 } else {
                     // after ok, we clear - ok should mean the window gets closed
                     if (isOk) {
                         clear(mapping, errors, form, request, response, session);
                     }
                     // otherwise the subclass will have to work out for itself what
                     // to do!
                 }
             } else {
                 forward = execute(mapping, errors, form, request, response,
                         session);
             }
             // if we have errors Report them
             if (errors.size() != 0) {
                 saveErrors(request, (ActionMessages) errors);
                 saveToken(request);
             }
             // if the forward is null, return control to the input screen            
             if (forward == null) {
                 return mapping.getInputForward();
             }
             // if the action forward is not defined, also return to the input
             ActionForward actionForward = mapping.findForward(forward);
             if (actionForward == null) {
                 return mapping.getInputForward();
             }
             return actionForward;
         } catch (Exception e) {
             // save this exception for the standard error page
             request.setAttribute("exception", e);
             return mapping.findForward("error");
         }
     }
     /***
      * <p>
      * This mask authenticator will be used to confirm whether or not the user
      * should be allowed to continue.
      * </p>
      *
      * @return Returns the authenticator.
      */
     protected MaskAuthenticator getAuthenticator() {
         return authenticator;
     }
     /***
      * <p>
      * Helper method to see if the parameter with the given name is set in the
      * request and, if not, if it is set in the form provided.
      * </p>
      *
      * @param name
      *            the name of the parameter to look for.
      * @param request
      *            servlet request to look for the parameter in.
      * @param form
      *            the form to search for the parameter, if it is not found in
      *            the request.
      * @return value from the request parameter with the name given. If that is
      *         null, then the value of the form attribute is returned, or
      *         <code>null</code> if there is no parameter or form attribute
      *         with the given name.
      * @throws SystemException
      *             if there is an <code>InvocationTargetException</code> or an
      *             <code>IllegalAccessException</code> accessing the
      *             parameter.
      */
     protected final String getFromRequestOrForm(final String name,
             final HttpServletRequest request, final ActionForm form)
             throws SystemException {
         return getFromRequestOrForm(name, request, form, null);
     }
     /***
      * <p>
      * Helper method to see if the parameter with the given name is set in the
      * request and, if not, if it is set in the form provided.
      * </p>
      *
      * @param name
      *            the name of the parameter to look for.
      * @param request
      *            servlet request to look for the parameter in.
      * @param form
      *            the form to search for the parameter, if it is not found in
      *            the request.
      * @return value from the request parameter with the name given. If that is
      *         null, then the value of the form attribute is returned, or
      *         <code>defaultValue</code> if there is no parameter or form
      *  attribute with the given name.
      * @throws SystemException
      *             if there is an <code>InvocationTargetException</code> or an
      *             <code>IllegalAccessException</code> accessing the
      *             parameter.
      */
     protected final String getFromRequestOrForm(final String name,
             final HttpServletRequest request, final ActionForm form,
             String defaultValue)
             throws SystemException {
         String value = request.getParameter(name);
         // if it was in the request, we need go no further
         if (value != null) {
             return value;
         }
         // if there is no form, just return null
         if (form == null) {
             return defaultValue;
         }
         // try to get it from the form
         try {
             value = (String) PropertyUtils.getSimpleProperty(form, name);
         } catch (NoSuchMethodException e) {
             // well if there is no method in the form, it will just have to be
             // null
             value = defaultValue;
         } catch (InvocationTargetException e) {
             throw new SystemException(e);
         } catch (IllegalAccessException e) {
             throw new SystemException(e);
         }
         return value;
     }
     /***
      * <p>
      * This method ascertains the correct input mask to use. First it looks for
      * an override in the request, then it looks for a parameter in the current
      * form before finally using the default.
      * </p>
      *
      * @param request
      *            servlet request we are processing. A request parameter will be
      *            first checked here.
      * @param form
      *            the form currently being processed. If there is no request
      *            parameter, the property &quot;inputMask&quot; is read from the
      *            form.
      * @return string representing the action to perform for the current input
      *         mask.
      * @throws SystemException
      *             if the input mask cannot be retrieved.
      */
     protected final String getInputMask(final HttpServletRequest request,
             final Object form) throws SystemException {
         String inputMask = request.getParameter("inputMask");
         if ((inputMask == null) && (form != null)) {
             try {
                 inputMask = (String) PropertyUtils.getProperty(form,
                         "inputMask");
             } catch (IllegalAccessException e) {
                 e.printStackTrace();
                 throw new SystemException(e);
             } catch (InvocationTargetException e) {
                 e.printStackTrace();
                 throw new SystemException(e);
             } catch (NoSuchMethodException e) {
                 // this is ok - just means the form didn't have this property
                 if (logger.isDebugEnabled()) {
                     logger.debug(
                             "NoSuchMethodException found looking for property '"
                                     + "inputMask'", e);
                 }
             }
         }
         if (inputMask == null) {
             inputMask = maskFactory.getDefaultInputMask();
         }
         return inputMask;
     }
     /***
      * <p>
      * This method ascertains the correct list mask to use. First it looks for
      * an override in the request, then it looks for a parameter in the current
      * form before finally using the default.
      * </p>
      *
      * @param request
      *            servlet request we are processing. A request parameter will be
      *            first checked here.
      * @param form
      *            the form currently being processed. If there is no request
      *            parameter, the property &quot;listMask&quot; is read from the
      *            form.
      * @return string representing the action to perform for the current list
      *         mask.
      * @throws SystemException
      *             if the list mask cannot be retrieved.
      */
     protected final String getListMask(final HttpServletRequest request,
             final Object form) throws SystemException {
         String listMask = request.getParameter("listMask");
         if ((listMask == null) && (form != null)) {
             try {
                 listMask = (String) PropertyUtils.getProperty(form, "listMask");
             } catch (IllegalAccessException e) {
                 e.printStackTrace();
                 throw new SystemException(e);
             } catch (InvocationTargetException e) {
                 e.printStackTrace();
                 throw new SystemException(e);
             } catch (NoSuchMethodException e) {
                 // this is ok - just means the form didn't have this property
                 logger.debug("NoSuchMethodException found looking for property '"
                         + "listMask' in form '"
                         + form.toString()
                         + "'; (this is normally ok)", e);
             }
         }
         if (listMask == null) {
             listMask = maskFactory.getDefaultListMask();
         }
         return listMask;
     }
     /***
      * <p>
      * This factory is needed to access the masks and groups of masks.
      * </p>
      *
      * @return Returns the maskFactory, used to access masks and groups of
      * masks.
      */
     protected MaskFactory getMaskFactory() {
         return maskFactory;
     }
     /***
      * Not sure why I needed to override this!
      *
      * Refer to {@link org.apache.struts.action.Action#isCancelled}.
      *
      * @param request
      *            Refer to {@link org.apache.struts.action.Action#isCancelled}.
      * @return Refer to {@link org.apache.struts.action.Action#isCancelled}.
      * @see org.apache.struts.action.Action#isCancelled
      */
     protected final boolean isCancelled(final HttpServletRequest request) {
         return (!"true".equals(request.getAttribute(CANCEL_COMPLETE)))
                 &&
                     ((request.getParameter("cancel") != null)
                             || (request.getParameter(Constants.CANCEL_PROPERTY)
                                     != null)
                             || (request
                                     .getParameter(Constants.CANCEL_PROPERTY_X)
                                         != null));
     }
     /***
      * <p>
      * This method is called if the ok or apply buttons are pressed.
      * </p>
      *
      * @param mapping
      *            The ActionMapping used to select this instance.
      * @param errors
      *            valid errors object to append errors to. If there are any
      *            errors, the action will return to the input.
      * @param form
      *            optional ActionForm bean for this request (if any)
      * @param request
      *            non-HTTP request we are processing
      * @param response
      *            The non-HTTP response we are creating
      * @param session
      *            returned from the <code>request</code> parameter.
      * @param defaultForward &quot;ok&quot; if the <code>Ok</code> button
      * was pressed, otherwise &quot;apply&quot; if the <code>Apply</code> button
      * was pressed.
      * @throws SystemException
      *             if there is any problem which prevents processing. It will
      *             result in the webapp being forwarded to the standard error
      *             page.
      * @return this method returns the string used to identify the correct
      *         <strong>Struts </strong> <code>ActionForward</code> which
      *         should follow this page, or <code>null</code> if it should
      *         return to the input.
      */
     public String onConfirm(final ActionMapping mapping,
             final ActionErrors errors, final ActionForm form,
             final HttpServletRequest request,
             final HttpServletResponse response, final HttpSession session,
             final String defaultForward) throws SystemException {
         // default implementation just goes back to standard execute routine
         execute(mapping, errors, form, request, response, session);
         return defaultForward;
     }
     /***
      * <p>
      * This method is called if the delete (confirm, not warn) button is
      * pressed.
      * </p>
      * @param mapping
      *            The ActionMapping used to select this instance.
      * @param errors
      *            valid errors object to append errors to. If there are any
      *            errors, the action will return to the input.
      * @param form
      *            optional ActionForm bean for this request (if any)
      * @param request
      *            non-HTTP request we are processing
      * @param response
      *            The non-HTTP response we are creating
      * @param session
      *            returned from the <code>request</code> parameter.
      * @param defaultForward usually &quot;delete&quot;. This is the forward
      * it is suggested you use, if everything is ok.
      * @exception SystemException
      *                if there is any problem which prevents processing. It will
      *                result in the webapp being forwarded to the standard error
      *                page.
      * @return this method returns the string used to identify the correct
      *         <strong>Struts </strong> <code>ActionForward</code> which
      *         should follow this page, or <code>null</code> if it should
      *         return to the input.
      */
     public String onDelete(final ActionMapping mapping,
             final ActionErrors errors, final ActionForm form,
             final HttpServletRequest request,
             final HttpServletResponse response,
             final HttpSession session,
             final String defaultForward)
             throws SystemException {
         // default implementation just goes back to standard execute routine
         execute(mapping, errors, form, request, response, session);
         return defaultForward;
     }
     /***
      * <p>
      * Set to <code>true</code> by <code>LoginAction</code> to indicate the
      * user name should not be checked.
      * </p>
      *
      * @param loginParam
      *            the new value of login.
      */
     public final void setLogin(final boolean loginParam) {
         this.login = loginParam;
     }
 }