Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2004-2005 Graeme Rocher
   *
   * Licensed 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.codehaus.groovy.grails.web.mapping;
 
 
 import java.util.Map;
 
The default implementation of the UrlCreator interface that constructs URLs in Grails default pattern of /controllerName/actionName/id.

Author(s):
Graeme Rocher
Since:
0.5.5
 
 @SuppressWarnings("rawtypes")
 public class DefaultUrlCreator implements UrlCreator {
 
     private static final char SLASH = '/';
     private final String controllerName;
     private final String actionName;
     public static final String ARGUMENT_ID = "id";
     private static final String ENTITY_AMPERSAND = "&";
 
     public DefaultUrlCreator(String controllerString action) {
          = controller;
          = action;
     }
 
     public String createURL(Map parameterValuesString encoding) {
         if (parameterValues == nullparameterValues = .;
         GrailsWebRequest webRequest = (GrailsWebRequest) RequestContextHolder.getRequestAttributes();
         return createURLWithWebRequest(parameterValueswebRequesttrue);
     }
 
     public String createURL(Map parameterValuesString encodingString fragment) {
         String url = createURL(parameterValuesencoding);
         return createUrlWithFragment(encodingfragmenturl);
     }
 
     @SuppressWarnings("unchecked")
     private String createURLWithWebRequest(Map parameterValuesGrailsWebRequest webRequestboolean includeContextPath) {
 
         GrailsRequestStateLookupStrategy requestStateLookupStrategy = new DefaultRequestStateLookupStrategy(webRequest);
 
         final String encoding = requestStateLookupStrategy.getCharacterEncoding();
 
         String id = null;
         if (parameterValues.containsKey()) {
             Object o = parameterValues.get();
             if (o != null) {
                 id = o.toString();
             }
         }
 
         FastStringWriter actualUriBuf = new FastStringWriter();
         if (includeContextPath) {
             actualUriBuf.append(requestStateLookupStrategy.getContextPath());
         }
         if ( != null) {
             if (.indexOf() > -1) {
                 actualUriBuf.append();
             }
             else {
                 if ( != null) {
                     appendUrlToken(actualUriBufencoding);
                 }
                 else {
                     appendUrlToken(actualUriBufrequestStateLookupStrategy.getControllerName(), encoding);
                 }
             }
            appendUrlToken(actualUriBufencoding);
        }
        if (id != null) {
            appendUrlToken(actualUriBufidencoding);
        }
        appendRequestParams(actualUriBufparameterValuesencoding);
        return actualUriBuf.toString();
    }
    public String createURL(String controllerString actionMap parameterValuesString encoding) {
        return createURL(controlleractionnullnullparameterValuesencoding);
    }
    public String createURL(String controllerString actionString pluginNameMap parameterValuesString encoding) {
        return createURL(controlleractionnullpluginNameparameterValuesencoding);
    }
    @SuppressWarnings("unchecked")
    public String createURL(String controllerString actionString namespaceString pluginNameMap parameterValuesString encoding) {
        return createURLInternal(controlleractionparameterValuestrue);
    }
    private String createURLInternal(String controllerString actionMap<StringStringparameterValuesboolean includeContextPath) {
        GrailsWebRequest webRequest = (GrailsWebRequest) RequestContextHolder.getRequestAttributes();
        if (parameterValues == nullparameterValues = new HashMap<StringString>();
        boolean blankController = StringUtils.isBlank(controller);
        boolean blankAction = StringUtils.isBlank(action);
        if (!blankController) {
            parameterValues.put(.controller);
        }
        if (!blankAction) {
            parameterValues.put(.action);
        }
        try {
            return createURLWithWebRequest(parameterValueswebRequestincludeContextPath);
        }
        finally {
            if (!blankController) {
                parameterValues.remove(.);
            }
            if (!blankAction) {
                parameterValues.remove(.);
            }
        }
    }
    public String createRelativeURL(String controllerString actionMap parameterValuesString encoding) {
        return createRelativeURL(controlleractionnullnullparameterValuesencoding);
    }
    public String createRelativeURL(String controllerString actionString pluginNameMap parameterValuesString encoding) {
        return createRelativeURL(controlleractionnullnullparameterValuesencoding);
    }
    @SuppressWarnings("unchecked")
    public String createRelativeURL(String controllerString actionString namespaceString pluginNameMap parameterValuesString encoding) {
        return createURLInternal(controlleractionparameterValuesfalse);
    }
    public String createRelativeURL(String controllerString actionMap parameterValuesString encodingString fragment) {
        return createRelativeURL(controlleractionnullnullparameterValuesencodingfragment);
    }
    @SuppressWarnings("unchecked")
    public String createRelativeURL(String controllerString actionString namespaceString pluginNameMap parameterValuesString encodingString fragment) {
        final String url = createURLInternal(controlleractionparameterValuesfalse);
        return  createUrlWithFragment(encodingfragmenturl);
    }
    public String createURL(String controllerString actionMap parameterValuesString encodingString fragment) {
        return createURL(controlleractionnullnullparameterValuesencodingfragment);
    }
    public String createURL(String controllerString actionString namespaceString pluginNameMap parameterValuesString encodingString fragment) {
        String url = createURL(controlleractionnamespacepluginNameparameterValuesencoding);
        return createUrlWithFragment(encodingfragmenturl);
    }
    private String createUrlWithFragment(String encodingString fragmentString url) {
        if (fragment != null) {
            try {
                return url + '#' + URLEncoder.encode(fragmentencoding);
            }
            catch (UnsupportedEncodingException ex) {
                throw new ControllerExecutionException("Error creating URL  [" + url +
                     "], problem encoding URL fragment [" + fragment + "]: " + ex.getMessage(),ex);
            }
        }
        return url;
    }
    /*
     * Appends all the request parameters to the URI buffer
     */
    private void appendRequestParams(FastStringWriter actualUriBufMap<ObjectObjectparamsString encoding) {
        boolean querySeparator = false;
        for (Map.Entry<ObjectObjectentry : params.entrySet()) {
            Object name = entry.getKey();
            if (name.equals(.) || name.equals(.) || name.equals()) {
                continue;
            }
            if (!querySeparator) {
                actualUriBuf.append('?');
                querySeparator = true;
            }
            else {
                actualUriBuf.append();
            }
            Object value = entry.getValue();
            if (value instanceof Collection) {
                Collection values = (Collectionvalue;
                Iterator valueIterator = values.iterator();
                while (valueIterator.hasNext()) {
                    Object currentValue = valueIterator.next();
                    appendRequestParam(actualUriBufnamecurrentValueencoding);
                    if (valueIterator.hasNext()) {
                        actualUriBuf.append();
                    }
                }
            }
            else if (value != null && value.getClass().isArray()) {
                Object[] array = (Object[]) value;
                for (int j = 0; j < array.lengthj++) {
                    Object currentValue = array[j];
                    appendRequestParam(actualUriBufnamecurrentValueencoding);
                    if (j < (array.length-1)) {
                        actualUriBuf.append();
                    }
                }
            }
            else {
                appendRequestParam(actualUriBufnamevalueencoding);
            }
        }
    }
    /*
     * Appends a request parameters for the given aname and value
     */
    private void appendRequestParam(FastStringWriter actualUriBufObject name,
            Object valueString encoding) {
        if (value == null) {
            value = "";
        }
        actualUriBuf.append(urlEncode(nameencoding))
                    .append('=')
                    .append(urlEncode(valueencoding));
    }
    private String urlEncode(Object objString charset) {
        try {
            return URLEncoder.encode(obj.toString(), (charset != null) ? charset : .);
        }
        catch (UnsupportedEncodingException ex) {
            throw new ControllerExecutionException(
                    "Error creating URL, cannot URLEncode to the client's character encoding: " + ex.getMessage(), ex);
        }
    }
    /*
     * Appends a URL token to the buffer
     */
    private void appendUrlToken(FastStringWriter actualUriBufObject tokenString charset) {
        actualUriBuf.append().append(urlEncode(tokencharset));
    }
New to GrepCode? Check out our FAQ X