Question

My form has a list of items, and each item has a delete button. I need to submit the index of the item to be deleted, along with the other values of the form (for further editing).

With JavaScript, it looks like this:

<g:form method="post" mapping="defaultAction" id="${paymentInstance?.id}">
    <g:hiddenField name="id" value="${paymentInstance?.id}"/>
    <g:hiddenField name="version" value="${paymentInstance?.version}"/>
    <g:hiddenField name="deleteAdjIdx"/>
    <g:each in="${paymentInstance?.adjustments}" var="adj" status="idx">
        <g:set var="adjName" value="adjustments[${idx}]"/>
        <g:textField name="${adjName}.dollars" value="${adj.dollars}"/>
        <g:actionSubmit action="deleteAdj" value="delete" onclick="jQuery('#deleteAdjIdx').val(${idx})"/>
    </g:each>
</g:form>

How can I do this without JavaScript? (Can I add a param to the URL, in addition to the posted params? Or, some kind of multiplex in the mapping?)

The defaultAction mapping is:

    name defaultAction: "/$controller/$id"{     // stable URL for payments regardless of current status (editable or not)
        constraints {
            id(matches: /\d+/)      // since our action names don't start with a digit but many domain ids do
        }
    }

Answer 1

I’m going to try adding params to the action name in an actionSubmit:

<my:actionSubmit action="deleteAdj" value="delete" params="${[deleteAdjIdx: idx]})"/>

I didn’t find a nice way to do this, so I came up with the following hack. If anyone knows of any improvements, I’d appreciate it.

Added to MyTagLib:

import org.codehaus.groovy.grails.web.util.WebUtils

def actionSubmit = { attrs ->
    String action = attrs.action ?: attrs.value
    Map params = attrs.remove('params')
    if (params) {
        attrs.action = (action + WebUtils.toQueryString(params)).encodeAsURL()
    }
    out << g.actionSubmit(attrs)
}

I unpack the params and restore the original action name in a filter:

package com.example;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.springframework.web.filter.GenericFilterBean
import org.codehaus.groovy.grails.web.util.WebUtils
import com.example.util.MyWebUtils
import javax.servlet.http.HttpServletRequest;

/**
 * Handles params packed into the MyTagLib.actionSubmit param name.
 * This Filter needs to come before GrailsWebRequestFilter.
 * <p/>
 * Updating the GrailsParameterMap after the GrailsWebRequestFilter doesn't work,
 * because the request given to DefaultUrlMappingInfo.checkDispatchAction()
 * is the immutable request saved in the GrailsWebRequest, not the wrapped request
 * that this filter passes on down the chain.
 */
public class ActionSubmitParamFilter extends GenericFilterBean {

    final static QUERY_SEPARATOR = '?'
    final static QUERY_SEPARATOR_REGEX = '[?]'
    final static PARAM_SEPARATOR_REGEX = '[&]'

    @Override
    void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain) throws IOException, ServletException {
        def dispatchAction = request.parameterNames.find {it.startsWith(WebUtils.DISPATCH_ACTION_PARAMETER)}
        def decoded = dispatchAction?.decodeURL()
        if (decoded?.contains(QUERY_SEPARATOR)) {
            def overrides = unpackParams(decoded)
            overrides[dispatchAction] = null   // deletes from the overridden request params
            request = MyWebUtils.overrideParams((HttpServletRequest) request, overrides)
        }
        chain.doFilter(request, response);
    }

    private Map unpackParams(String decoded) {
        String action, paramsPart
        (action, paramsPart) = decoded.split(QUERY_SEPARATOR_REGEX)
        assert action.startsWith(WebUtils.DISPATCH_ACTION_PARAMETER)
        def packedParams = [:].withDefault {[]}
        packedParams[action] << ''

        for (param in paramsPart.split(PARAM_SEPARATOR_REGEX)) {
            if (param.contains('=')) {
                def (name, value) = param.split('=')
                packedParams[name.decodeURL()] << value.decodeURL()
            } else {
                packedParams[param.decodeURL()] << ''
            }
        }
        packedParams
    }
}

I made utility methods to override the request params and configure the filter:

package com.example.util

import org.springframework.web.multipart.MultipartHttpServletRequest
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletRequestWrapper
import groovy.util.slurpersupport.GPathResult
import com.example.ActionSubmitParamFilter

class MyWebUtils {

    static HttpServletRequest overrideParams(HttpServletRequest original, Map<String, List<String>> overrides) {
        assert !(original instanceof MultipartHttpServletRequest)   // if we get one of these, we'll need to use a special wrapper

        def params = (Map<String, String[]>) new HashMap(original.getParameterMap())
        overrides.each {k, v ->
            if (v == null) {
                params.remove(k)    // significant for parameterNames enumeration and parameterMap
            } else {
                params[k] = v as String[]
            }
        }
        params = Collections.unmodifiableMap(params)
        new HttpServletRequestWrapper(original) {

            @Override
            String[] getParameterValues(String name) {
                params[name]
            }

            @Override
            String getParameter(String name) {
                String[] values = params[name]
                values ? values[0] : (values == null ? null : '')
            }

            @Override
            Map getParameterMap() {
                params
            }

            @Override
            Enumeration getParameterNames() {
                Collections.enumeration(params.keySet())
            }
        }
    }


    // used dynamically by _Events.eventWebXmlStart
    static void prependActionSubmitParamFilter(GPathResult webXml) {

        def filters = webXml.filter
        def filterMappings = webXml.'filter-mapping'

        def firstFilter = filters[0]
        def firstFilterMapping = filterMappings[0]

        firstFilter + {
            filter {
                'filter-name'('actionSubmitParam')
                'filter-class'(ActionSubmitParamFilter.name)
            }
        }

        firstFilterMapping + {
            'filter-mapping' {
                'filter-name'('actionSubmitParam')
                'url-pattern'("/*")
                'dispatcher'("FORWARD")
                'dispatcher'("REQUEST")
            }
        }
    }
}

Finally, I added the following to _Events.groovy to configure the filter in web.xml by extending ControllersGrailsPlugin.doWithWebDescriptor:

eventWebXmlStart = {

    pluginManager.getGrailsPlugin('controllers').with {
        def originalClosure = instance.doWithWebDescriptor  // extending
        instance.doWithWebDescriptor = { GPathResult webXml ->

            // static import fails after clean (before compile), so load dynamically
            def webUtils = getClass().classLoader.loadClass('com.example.util.MyWebUtils')
            webUtils.prependActionSubmitParamFilter(webXml)

            // call super after (so above filter comes before GrailsWebRequestFilter in chain)
            originalClosure.resolveStrategy = Closure.DELEGATE_FIRST
            originalClosure.delegate = delegate
            originalClosure(webXml)
        }
    }
}