Coverage report

  %line %branch
org.apache.turbine.util.DynamicURI
23% 
91% 

 1  
 package org.apache.turbine.util;
 2  
 
 3  
 /*
 4  
  * Copyright 2001-2005 The Apache Software Foundation.
 5  
  *
 6  
  * Licensed under the Apache License, Version 2.0 (the "License")
 7  
  * you may not use this file except in compliance with the License.
 8  
  * You may obtain a copy of the License at
 9  
  *
 10  
  *     http://www.apache.org/licenses/LICENSE-2.0
 11  
  *
 12  
  * Unless required by applicable law or agreed to in writing, software
 13  
  * distributed under the License is distributed on an "AS IS" BASIS,
 14  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15  
  * See the License for the specific language governing permissions and
 16  
  * limitations under the License.
 17  
  */
 18  
 
 19  
 import java.net.URLEncoder;
 20  
 
 21  
 import java.util.ArrayList;
 22  
 import java.util.Iterator;
 23  
 import java.util.List;
 24  
 
 25  
 import javax.servlet.http.HttpServletRequest;
 26  
 import javax.servlet.http.HttpServletResponse;
 27  
 
 28  
 import org.apache.commons.lang.StringUtils;
 29  
 
 30  
 import org.apache.commons.logging.Log;
 31  
 import org.apache.commons.logging.LogFactory;
 32  
 
 33  
 import org.apache.ecs.html.A;
 34  
 
 35  
 import org.apache.turbine.Turbine;
 36  
 import org.apache.turbine.TurbineConstants;
 37  
 import org.apache.turbine.util.parser.ParameterParser;
 38  
 import org.apache.turbine.util.parser.ParserUtils;
 39  
 import org.apache.turbine.util.uri.URI;
 40  
 import org.apache.turbine.util.uri.URIConstants;
 41  
 
 42  
 /**
 43  
  * This creates a Dynamic URI for use within the Turbine system
 44  
  *
 45  
  * <p>If you use this class to generate all of your href tags as well
 46  
  * as all of your URI's, then you will not need to worry about having
 47  
  * session data setup for you or using HttpServletRequest.encodeUrl()
 48  
  * since this class does everything for you.
 49  
  *
 50  
  * <code><pre>
 51  
  * DynamicURI dui = new DynamicURI (data, "UserScreen" );
 52  
  * dui.setName("Click Here").addPathInfo("user","jon");
 53  
  * dui.getA();
 54  
  * </pre></code>
 55  
  *
 56  
  * The above call to getA() would return the String:
 57  
  *
 58  
  * &lt;A HREF="http://www.server.com:80/servlets/Turbine/screen=UserScreen&amp;amp;user=jon"&gt;Click Here&lt;/A&gt;
 59  
  *
 60  
  * @todo Add support for returning the correct URI when mod_rewrite is
 61  
  *       being used.
 62  
  *
 63  
  * @author <a href="mailto:jon@clearink.com">Jon S. Stevens</a>
 64  
  * @author <a href="mailto:jvanzyl@periapt.com">Jason van Zyl</a>
 65  
  * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
 66  
  * @version $Id: DynamicURI.java 264148 2005-08-29 14:21:04Z henning $
 67  
  * @deprecated Use {@link org.apache.turbine.util.uri.TurbineURI} instead.
 68  
  */
 69  1
 public class DynamicURI
 70  
         implements URI
 71  
 {
 72  
     /** @deprecated Use URIConstants.HTTP */
 73  
     public static final String HTTP = URIConstants.HTTP;
 74  
 
 75  
     /** @deprecated Use URIConstants.HTTPS */
 76  
     public static final String HTTPS = URIConstants.HTTPS;
 77  
 
 78  
     /** Logging */
 79  3
     private static Log log = LogFactory.getLog(DynamicURI.class);
 80  
 
 81  
     /** The ServerData object. */
 82  2
     protected ServerData sd = null;
 83  
 
 84  
     /** The RunData object. */
 85  2
     protected RunData data = null;
 86  
 
 87  
     /** #ref */
 88  2
     protected String reference = null;
 89  
 
 90  
     // Used with RunData constructors to provide a way around a JServ
 91  
     // 1.0 bug.
 92  
 
 93  
     /** Servlet response interface. */
 94  2
     public HttpServletResponse res = null;
 95  
 
 96  
     /** A List that contains all the path info if any. */
 97  2
     protected List pathInfo = null;
 98  
 
 99  
     /** A List that contains all the query data if any. */
 100  2
     protected List queryData = null;
 101  
 
 102  
     /** Fast shortcut to determine if there is any data in the path info. */
 103  2
     protected boolean hasPathInfo = false;
 104  
 
 105  
     /** Fast shortcut to determine if there is any data in the query data. */
 106  2
     protected boolean hasQueryData = false;
 107  
 
 108  
     /** Whether we want to redirect or not. */
 109  2
     protected boolean redirect = false;
 110  
 
 111  
     /** P = 0 for path info. */
 112  
     protected static final int PATH_INFO = 0;
 113  
 
 114  
     /** Q = 1 for query data. */
 115  
     protected static final int QUERY_DATA = 1;
 116  
 
 117  
     /** Has the object been initialized? */
 118  2
     private boolean initialized = false;
 119  
 
 120  
     /**
 121  
      * Constructor sets up some variables.
 122  
      *
 123  
      * @param data A Turbine RunData object.
 124  
      */
 125  
     public DynamicURI(RunData data)
 126  0
     {
 127  0
         init(data);
 128  0
     }
 129  
 
 130  
     /**
 131  
      * Default constructor - one of the init methods must be called
 132  
      * before use.
 133  
      */
 134  
     public DynamicURI()
 135  0
     {
 136  0
     }
 137  
 
 138  
     /**
 139  
      * Constructor sets up some variables.
 140  
      *
 141  
      * @param data A Turbine RunData object.
 142  
      * @param screen A String with the name of a screen.
 143  
      */
 144  
     public DynamicURI(RunData data, String screen)
 145  
     {
 146  0
         this(data);
 147  0
         setScreen(screen);
 148  0
     }
 149  
 
 150  
     /**
 151  
      * Constructor sets up some variables.
 152  
      *
 153  
      * @param data A Turbine RunData object.
 154  
      * @param screen A String with the name of a screen.
 155  
      * @param action A String with the name of an action.
 156  
      */
 157  
     public DynamicURI(RunData data, String screen, String action)
 158  
     {
 159  0
         this(data, screen);
 160  0
         setAction(action);
 161  0
     }
 162  
 
 163  
     /**
 164  
      * Constructor sets up some variables.
 165  
      *
 166  
      * @param data A Turbine RunData object.
 167  
      * @param screen A String with the name of a screen.
 168  
      * @param action A String with the name of an action.
 169  
      * @param redirect True if it should redirect.
 170  
      */
 171  
     public DynamicURI(RunData data,String screen,
 172  
                       String action,boolean redirect)
 173  
     {
 174  0
         this(data, screen, action);
 175  0
         this.redirect = redirect;
 176  0
     }
 177  
 
 178  
     /**
 179  
      * Constructor sets up some variables.
 180  
      *
 181  
      * @param data A Turbine RunData object.
 182  
      * @param screen A String with the name of a screen.
 183  
      * @param redirect True if it should redirect.
 184  
      */
 185  
     public DynamicURI(RunData data, String screen, boolean redirect)
 186  
     {
 187  0
         this(data, screen);
 188  0
         this.redirect = redirect;
 189  0
     }
 190  
 
 191  
     /**
 192  
      * Constructor sets up some variables.
 193  
      *
 194  
      * @param data A Turbine RunData object.
 195  
      * @param redirect True if it should redirect.
 196  
      */
 197  
     public DynamicURI(RunData data, boolean redirect)
 198  
     {
 199  0
         this(data);
 200  0
         this.redirect = redirect;
 201  0
     }
 202  
 
 203  
     /**
 204  
      * Main constructor for DynamicURI.  Uses ServerData.
 205  
      *
 206  
      * @param sd A ServerData.
 207  
      */
 208  
     public DynamicURI(ServerData sd)
 209  2
     {
 210  2
         init(sd);
 211  2
     }
 212  
 
 213  
     /**
 214  
      * Main constructor for DynamicURI.  Uses ServerData.
 215  
      *
 216  
      * @param sd A ServerData.
 217  
      * @param screen A String with the name of a screen.
 218  
      */
 219  
     public DynamicURI(ServerData sd, String screen)
 220  
     {
 221  0
         this(sd);
 222  0
         setScreen(screen);
 223  0
     }
 224  
 
 225  
     /**
 226  
      * Main constructor for DynamicURI.  Uses ServerData.
 227  
      *
 228  
      * @param sd A ServerData.
 229  
      * @param screen A String with the name of a screen.
 230  
      * @param action A String with the name of an action.
 231  
      */
 232  
     public DynamicURI(ServerData sd, String screen, String action)
 233  
     {
 234  0
         this(sd, screen);
 235  0
         setAction(action);
 236  0
     }
 237  
 
 238  
     /**
 239  
      * Main constructor for DynamicURI.  Uses ServerData.
 240  
      *
 241  
      * @param sd A ServerData.
 242  
      * @param screen A String with the name of a screen.
 243  
      * @param action A String with the name of an action.
 244  
      * @param redirect True if it should redirect.
 245  
      */
 246  
     public DynamicURI(ServerData sd, String screen,
 247  
                       String action, boolean redirect)
 248  
     {
 249  0
         this(sd, screen, action);
 250  0
         this.redirect = redirect;
 251  0
     }
 252  
 
 253  
     /**
 254  
      * Main constructor for DynamicURI.  Uses ServerData.
 255  
      *
 256  
      * @param serverData A ServerData.
 257  
      * @param screen A String with the name of a screen.
 258  
      * @param redirect True if it should redirect.
 259  
      */
 260  
     public DynamicURI(ServerData serverData, String screen, boolean redirect)
 261  
     {
 262  0
         this(serverData, screen);
 263  0
         this.redirect = redirect;
 264  0
     }
 265  
 
 266  
     /**
 267  
      * Main constructor for DynamicURI.  Uses ServerData.
 268  
      *
 269  
      * @param serverData A ServerData.
 270  
      * @param redirect True if it should redirect.
 271  
      */
 272  
     public DynamicURI(ServerData serverData, boolean redirect)
 273  
     {
 274  0
         this(serverData);
 275  0
         this.redirect = redirect;
 276  0
         this.initialized = true;
 277  0
     }
 278  
 
 279  
     /**
 280  
      * Initialize with a RunData object
 281  
      *
 282  
      * @param data RunData instance
 283  
      */
 284  
     public void init(RunData data)
 285  
     {
 286  0
         init(data.getServerData());
 287  0
         this.data = data;
 288  0
         this.res = data.getResponse();
 289  0
     }
 290  
 
 291  
     /**
 292  
      * Initialize with a ServerData object.
 293  
      *
 294  
      * @param serverData
 295  
      */
 296  
     public void init(ServerData serverData)
 297  
     {
 298  2
         this.sd = (ServerData) serverData.clone();
 299  2
         this.pathInfo = new ArrayList();
 300  2
         this.queryData = new ArrayList();
 301  2
         this.reference = null;
 302  2
         this.initialized = true;
 303  2
     }
 304  
 
 305  
     /**
 306  
      * If the type is {@link #PATH_INFO}, then add name/value to the
 307  
      * pathInfo.
 308  
      * <p>
 309  
      * If the type is {@link #QUERY_DATA}, then add name/value to the
 310  
      * queryData.
 311  
      *
 312  
      * @param type Type of insertion.
 313  
      * @param name A String with the name to add.
 314  
      * @param value A String with the value to add.
 315  
      */
 316  
     protected void add(int type, String name, String value)
 317  
     {
 318  4
         assertInitialized();
 319  4
         Object[] tmp = new Object[2];
 320  4
         tmp[0] = ParserUtils.convertAndTrim(name);
 321  4
         tmp[1] = value;
 322  4
         switch (type)
 323  
         {
 324  
             case PATH_INFO:
 325  2
                 this.pathInfo.add(tmp);
 326  2
                 this.hasPathInfo = true;
 327  2
                 break;
 328  
             case QUERY_DATA:
 329  2
                 this.queryData.add(tmp);
 330  2
                 this.hasQueryData = true;
 331  
                 break;
 332  
         }
 333  4
     }
 334  
 
 335  
     /**
 336  
      * Method for a quick way to add all the parameters in a
 337  
      * ParameterParser.
 338  
      * <p>
 339  
      * If the type is {@link #PATH_INFO}, then add name/value to the
 340  
      * pathInfo.
 341  
      * <p>
 342  
      * If the type is {@link #QUERY_DATA}, then add name/value to the
 343  
      * queryData.
 344  
      *
 345  
      * @param type Type of insertion.
 346  
      * @param pp A ParameterParser.
 347  
      */
 348  
     protected void add(int type, ParameterParser pp)
 349  
     {
 350  0
         for( Iterator iter = pp.keySet().iterator(); iter.hasNext(); )
 351  
         {
 352  0
             String key = (String) iter.next();
 353  0
             if (!key.equalsIgnoreCase(URIConstants.CGI_ACTION_PARAM) &&
 354  
                     !key.equalsIgnoreCase(URIConstants.CGI_SCREEN_PARAM) &&
 355  
                     !key.equalsIgnoreCase(URIConstants.CGI_TEMPLATE_PARAM))
 356  
             {
 357  0
                 String[] values = pp.getStrings(key);
 358  0
                 for (int i = 0; i < values.length; i++)
 359  
                 {
 360  0
                     add(type, key, values[i]);
 361  
                 }
 362  
             }
 363  
         }
 364  0
     }
 365  
 
 366  
     /**
 367  
      * Adds a name=value pair to the path_info string.
 368  
      *
 369  
      * @param name A String with the name to add.
 370  
      * @param value An Object with the value to add.
 371  
      * @return A DynamicURI (self).
 372  
      */
 373  
     public DynamicURI addPathInfo(String name, Object value)
 374  
     {
 375  0
         add(PATH_INFO, name, value.toString());
 376  0
         return this;
 377  
     }
 378  
 
 379  
     /**
 380  
      * Adds a name=value pair to the path_info string.
 381  
      *
 382  
      * @param name A String with the name to add.
 383  
      * @param value A String with the value to add.
 384  
      * @return A DynamicURI (self).
 385  
      */
 386  
     public DynamicURI addPathInfo(String name, String value)
 387  
     {
 388  2
         add(PATH_INFO, name, value);
 389  2
         return this;
 390  
     }
 391  
 
 392  
     /**
 393  
      * Adds a name=value pair to the path_info string.
 394  
      *
 395  
      * @param name A String with the name to add.
 396  
      * @param value A double with the value to add.
 397  
      * @return A DynamicURI (self).
 398  
      */
 399  
     public DynamicURI addPathInfo(String name, double value)
 400  
     {
 401  0
         add(PATH_INFO, name, Double.toString(value));
 402  0
         return this;
 403  
     }
 404  
 
 405  
     /**
 406  
      * Adds a name=value pair to the path_info string.
 407  
      *
 408  
      * @param name A String with the name to add.
 409  
      * @param value An int with the value to add.
 410  
      * @return A DynamicURI (self).
 411  
      */
 412  
     public DynamicURI addPathInfo(String name, int value)
 413  
     {
 414  0
         add(PATH_INFO, name, String.valueOf(value));
 415  0
         return this;
 416  
     }
 417  
 
 418  
     /**
 419  
      * Adds a name=value pair to the path_info string.
 420  
      *
 421  
      * @param name A String with the name to add.
 422  
      * @param value A long with the value to add.
 423  
      * @return A DynamicURI (self).
 424  
      */
 425  
     public DynamicURI addPathInfo(String name, long value)
 426  
     {
 427  0
         add(PATH_INFO, name, String.valueOf(value));
 428  0
         return this;
 429  
     }
 430  
 
 431  
     /**
 432  
      * Adds a name=value pair for every entry in a ParameterParser
 433  
      * object to the path_info string.
 434  
      *
 435  
      * @param pp A ParameterParser.
 436  
      * @return A DynamicURI (self).
 437  
      */
 438  
     public DynamicURI addPathInfo(ParameterParser pp)
 439  
     {
 440  0
         add(PATH_INFO, pp);
 441  0
         return this;
 442  
     }
 443  
 
 444  
     /**
 445  
      * Adds a name=value pair to the query string.
 446  
      *
 447  
      * @param name A String with the name to add.
 448  
      * @param value An Object with the value to add.
 449  
      * @return A DynamicURI (self).
 450  
      */
 451  
     public DynamicURI addQueryData(String name, Object value)
 452  
     {
 453  0
         add(QUERY_DATA, name, value.toString());
 454  0
         return this;
 455  
     }
 456  
 
 457  
     /**
 458  
      * Adds a name=value pair to the query string.
 459  
      *
 460  
      * @param name A String with the name to add.
 461  
      * @param value A String with the value to add.
 462  
      * @return A DynamicURI (self).
 463  
      */
 464  
     public DynamicURI addQueryData(String name, String value)
 465  
     {
 466  2
         add(QUERY_DATA, name, value);
 467  2
         return this;
 468  
     }
 469  
 
 470  
     /**
 471  
      * Adds a name=value pair to the query string.
 472  
      *
 473  
      * @param name A String with the name to add.
 474  
      * @param value A double with the value to add.
 475  
      * @return A DynamicURI (self).
 476  
      */
 477  
     public DynamicURI addQueryData(String name, double value)
 478  
     {
 479  0
         add(QUERY_DATA, name, Double.toString(value));
 480  0
         return this;
 481  
     }
 482  
 
 483  
     /**
 484  
      * Adds a name=value pair to the query string.
 485  
      *
 486  
      * @param name A String with the name to add.
 487  
      * @param value An int with the value to add.
 488  
      * @return A DynamicURI (self).
 489  
      */
 490  
     public DynamicURI addQueryData(String name, int value)
 491  
     {
 492  0
         add(QUERY_DATA, name, String.valueOf(value));
 493  0
         return this;
 494  
     }
 495  
 
 496  
     /**
 497  
      * Adds a name=value pair to the query string.
 498  
      *
 499  
      * @param name A String with the name to add.
 500  
      * @param value A long with the value to add.
 501  
      * @return A DynamicURI (self).
 502  
      */
 503  
     public DynamicURI addQueryData(String name, long value)
 504  
     {
 505  0
         add(QUERY_DATA, name, String.valueOf(value));
 506  0
         return this;
 507  
     }
 508  
 
 509  
     /**
 510  
      * Adds a name=value pair for every entry in a ParameterParser
 511  
      * object to the query string.
 512  
      *
 513  
      * @param pp A ParameterParser.
 514  
      * @return A DynamicURI (self).
 515  
      */
 516  
     public DynamicURI addQueryData(ParameterParser pp)
 517  
     {
 518  0
         add(QUERY_DATA, pp);
 519  0
         return this;
 520  
     }
 521  
 
 522  
     /**
 523  
      * Create an anchor object.  This call to getA():
 524  
      *
 525  
      * <code><pre>
 526  
      * DynamicURI dui = new DynamicURI (data, "UserScreen" );
 527  
      * dui.setName("Click Here").addPathInfo("user","jon");
 528  
      * dui.getA();
 529  
      * </pre></code>
 530  
      *
 531  
      * would return the String:
 532  
      *
 533  
      * <p>&lt;A HREF="http://www.server.com:80/servlets/Turbine/screen=UserScreen&amp;amp;user=jon"&gt;Click Here&lt;/A&gt;
 534  
      *
 535  
      * @param name A String with the name for the anchor.
 536  
      * @return The anchor as a &lt;A HREF=""&gt;name&lt;/A&gt;.
 537  
      */
 538  
     public String getA(String name)
 539  
     {
 540  0
         return new A(this.toString(), name).toString();
 541  
     }
 542  
 
 543  
     /**
 544  
      * Gets the script name (/servlets/Turbine).
 545  
      *
 546  
      * @return A String with the script name.
 547  
      */
 548  
     public String getScriptName()
 549  
     {
 550  0
         String result = getServerData().getScriptName();
 551  0
         return (StringUtils.isEmpty(result) ? "" : result);
 552  
     }
 553  
 
 554  
     /**
 555  
      * Gets the context path
 556  
      *
 557  
      * @return A String with the servlet context path
 558  
      */
 559  
     public String getContextPath()
 560  
     {
 561  0
         String result = getServerData().getContextPath();
 562  0
         return (StringUtils.isEmpty(result) ? "" : result);
 563  
     }
 564  
 
 565  
     /**
 566  
      * Gets the reference (#ref).
 567  
      *
 568  
      * @return A String containing the reference.
 569  
      */
 570  
     public String getReference()
 571  
     {
 572  0
         assertInitialized();
 573  0
         return (StringUtils.isEmpty(this.reference) ? "" : this.reference);
 574  
     }
 575  
 
 576  
     /**
 577  
      * Gets the server name.
 578  
      *
 579  
      * @return A String with the server name.
 580  
      */
 581  
     public String getServerName()
 582  
     {
 583  0
         String result = getServerData().getServerName();
 584  0
         return (StringUtils.isEmpty(result) ? "" : result);
 585  
     }
 586  
 
 587  
     /**
 588  
      * Gets the server port.
 589  
      *
 590  
      * @return A String with the server port.
 591  
      */
 592  
     public int getServerPort()
 593  
     {
 594  0
         int result = getServerData().getServerPort();
 595  0
         return (result==0 ? URIConstants.HTTP_PORT : result);
 596  
     }
 597  
 
 598  
     /**
 599  
      * Gets the server scheme (HTTP or HTTPS).
 600  
      *
 601  
      * @return A String with the server scheme.
 602  
      */
 603  
     public String getServerScheme()
 604  
     {
 605  0
         String result = getServerData().getServerScheme();
 606  0
         return (StringUtils.isEmpty(result) ? "" : result);
 607  
     }
 608  
 
 609  
     /**
 610  
      * <p>If the type is {@link #PATH_INFO}, then remove name/value from the
 611  
      * pathInfo.
 612  
      *
 613  
      * <p>If the type is {@link #QUERY_DATA}, then remove name/value from the
 614  
      * queryData.
 615  
      *
 616  
      * @param type Type of removal.
 617  
      * @param name A String with the name to be removed.
 618  
      */
 619  
     protected void remove(int type, String name)
 620  
     {
 621  4
         assertInitialized();
 622  
         try
 623  
         {
 624  4
             switch (type)
 625  
             {
 626  
                 case PATH_INFO:
 627  2
                     for (Iterator iter = this.pathInfo.iterator();
 628  4
                          iter.hasNext();)
 629  
                     {
 630  2
                         Object[] tmp = (Object[]) iter.next();
 631  2
                         if (ParserUtils.convertAndTrim(name)
 632  
                                 .equals((String) tmp[0]))
 633  
                         {
 634  2
                             iter.remove();
 635  
                         }
 636  
                     }
 637  2
                     if (hasPathInfo && this.pathInfo.size() == 0)
 638  
                     {
 639  2
                         this.hasPathInfo = false;
 640  
                     }
 641  
                     break;
 642  
                 case QUERY_DATA:
 643  2
                     for (Iterator iter = this.pathInfo.iterator();
 644  2
                          iter.hasNext();)
 645  
                     {
 646  0
                         Object[] tmp = (Object[]) iter.next();
 647  0
                         if (ParserUtils.convertAndTrim(name)
 648  
                                 .equals((String) tmp[0]))
 649  
                         {
 650  0
                             iter.remove();
 651  
                         }
 652  
                     }
 653  2
                     if (hasQueryData && this.queryData.size() == 0)
 654  
                     {
 655  0
                         this.hasQueryData = false;
 656  
                     }
 657  
                     break;
 658  
             }
 659  2
         }
 660  0
         catch (Exception e)
 661  
         {
 662  0
             log.error("Could not remove "+name, e);
 663  2
         }
 664  4
     }
 665  
 
 666  
     /**
 667  
      * Removes all the path info elements.
 668  
      */
 669  
     public void removePathInfo()
 670  
     {
 671  0
         assertInitialized();
 672  0
         this.pathInfo.clear();
 673  0
         this.hasPathInfo = false;
 674  0
     }
 675  
 
 676  
     /**
 677  
      * Removes a name=value pair from the path info.
 678  
      *
 679  
      * @param name A String with the name to be removed.
 680  
      */
 681  
     public void removePathInfo(String name)
 682  
     {
 683  2
         remove(PATH_INFO, name);
 684  2
     }
 685  
 
 686  
     /**
 687  
      * Removes all the query string elements.
 688  
      */
 689  
     public void removeQueryData()
 690  
     {
 691  0
         assertInitialized();
 692  0
         this.queryData.clear();
 693  0
         this.hasQueryData = false;
 694  0
     }
 695  
 
 696  
     /**
 697  
      * Removes a name=value pair from the query string.
 698  
      *
 699  
      * @param name A String with the name to be removed.
 700  
      */
 701  
     public void removeQueryData(String name)
 702  
     {
 703  2
         remove(QUERY_DATA, name);
 704  2
     }
 705  
 
 706  
     /**
 707  
      * This method takes a List of key/value arrays and converts it
 708  
      * into a URL encoded querystring format.
 709  
      *
 710  
      * @param data A List of key/value arrays.
 711  
      * @return A String with the URL encoded data.
 712  
      */
 713  
     protected String renderPathInfo(List data)
 714  
     {
 715  0
         String key = null;
 716  0
         String value = null;
 717  0
         String tmp = null;
 718  0
         StringBuffer out = new StringBuffer();
 719  0
         for( Iterator iter = data.iterator(); iter.hasNext(); )
 720  
         {
 721  0
             Object[] stuff = (Object[]) iter.next();
 722  0
             key = URLEncoder.encode((String) stuff[0]);
 723  0
             tmp = (String) stuff[1];
 724  0
             if (tmp == null || tmp.length() == 0)
 725  
             {
 726  0
                 value = "null";
 727  
             }
 728  
             else
 729  
             {
 730  0
                 value = URLEncoder.encode(tmp);
 731  
             }
 732  
 
 733  0
             if (out.length() > 0)
 734  
             {
 735  0
                 out.append("/");
 736  
             }
 737  0
             out.append(key);
 738  0
             out.append("/");
 739  0
             out.append(value);
 740  
         }
 741  0
         return out.toString();
 742  
     }
 743  
 
 744  
     /**
 745  
      * This method takes a List of key/value arrays and converts it
 746  
      * into a URL encoded querystring format.
 747  
      *
 748  
      * @param data A List of key/value arrays.
 749  
      * @return A String with the URL encoded data.
 750  
      */
 751  
     protected String renderQueryString(List data)
 752  
     {
 753  0
         String key = null;
 754  0
         String value = null;
 755  0
         String tmp = null;
 756  0
         StringBuffer out = new StringBuffer();
 757  0
         for( Iterator iter = data.iterator(); iter.hasNext(); )
 758  
         {
 759  0
             Object[] stuff = (Object[]) iter.next();
 760  0
             key = URLEncoder.encode((String) stuff[0]);
 761  0
             tmp = (String) stuff[1];
 762  0
             if (tmp == null || tmp.length() == 0)
 763  
             {
 764  0
                 value = "null";
 765  
             }
 766  
             else
 767  
             {
 768  0
                 value = URLEncoder.encode(tmp);
 769  
             }
 770  
 
 771  0
             if (out.length() > 0)
 772  
             {
 773  0
                 out.append("&");
 774  
             }
 775  0
             out.append(key);
 776  0
             out.append("=");
 777  0
             out.append(value);
 778  
         }
 779  0
         return out.toString();
 780  
     }
 781  
 
 782  
     /**
 783  
      * Sets the action= value for this URL.
 784  
      *
 785  
      * <p>By default it adds the information to the path_info instead
 786  
      * of the query data.
 787  
      *
 788  
      * @param action A String with the action value.
 789  
      * @return A DynamicURI (self).
 790  
      */
 791  
     public DynamicURI setAction(String action)
 792  
     {
 793  0
         add(PATH_INFO, URIConstants.CGI_ACTION_PARAM, action);
 794  0
         return this;
 795  
     }
 796  
 
 797  
     /**
 798  
      * Sets the action= value for this URL and added eventSubmit_[eventName]
 799  
      * to the path_info.  The value of eventSubmit_[eventName] will be
 800  
      * [eventName].
 801  
      *
 802  
      * @param actionName name of the action to call
 803  
      * @param eventName name of the event.
 804  
      * @return A DynamicURI (self).
 805  
      */
 806  
     public DynamicURI setActionEvent(String actionName, String eventName)
 807  
     {
 808  0
         setAction(actionName).addPathInfo(
 809  
                 "eventSubmit_" + eventName, eventName);
 810  0
         return this;
 811  
     }
 812  
 
 813  
     /**
 814  
      * Sets the screen= value for this URL.
 815  
      *
 816  
      * <p>By default it adds the information to the path_info instead
 817  
      * of the query data.
 818  
      *
 819  
      * @param screen A String with the screen value.
 820  
      * @return A DynamicURI (self).
 821  
      */
 822  
     public DynamicURI setScreen(String screen)
 823  
     {
 824  0
         add(PATH_INFO, URIConstants.CGI_SCREEN_PARAM, screen);
 825  0
         return this;
 826  
     }
 827  
 
 828  
     /**
 829  
      * Sets the script name (/servlets/Turbine).
 830  
      *
 831  
      * @param name A String with the script name.
 832  
      * @return A DynamicURI (self).
 833  
      */
 834  
     public DynamicURI setScriptName(String name)
 835  
     {
 836  0
         getServerData().setScriptName(name);
 837  0
         return this;
 838  
     }
 839  
 
 840  
     /**
 841  
      * Sets the context path
 842  
      *
 843  
      * @param contextPath A String with the servlet context path
 844  
      * @return A DynamicURI (self).
 845  
      */
 846  
     public DynamicURI setContextPath(String contextPath)
 847  
     {
 848  0
         getServerData().setContextPath(contextPath);
 849  0
         return this;
 850  
     }
 851  
 
 852  
     /**
 853  
      * Sets the reference  (#ref).
 854  
      *
 855  
      * @param reference A String containing the reference.
 856  
      * @return A DynamicURI (self).
 857  
      */
 858  
     public DynamicURI setReference(String reference)
 859  
     {
 860  0
         this.reference = reference;
 861  0
         return this;
 862  
     }
 863  
 
 864  
     /**
 865  
      * Sets the server name.
 866  
      *
 867  
      * @param name A String with the server name.
 868  
      * @return A DynamicURI (self).
 869  
      */
 870  
     public DynamicURI setServerName(String name)
 871  
     {
 872  0
         getServerData().setServerName(name);
 873  0
         return this;
 874  
     }
 875  
 
 876  
     /**
 877  
      * Sets the server port.
 878  
      *
 879  
      * @param port An int with the port.
 880  
      * @return A DynamicURI (self).
 881  
      */
 882  
     public DynamicURI setServerPort(int port)
 883  
     {
 884  0
         getServerData().setServerPort(port);
 885  0
         return this;
 886  
     }
 887  
 
 888  
     /**
 889  
      * Method to specify that a URI should use SSL.  Whether or not it
 890  
      * does is determined from TurbineResources.properties.  Port
 891  
      * number is 443.
 892  
      *
 893  
      * @return A DynamicURI (self).
 894  
      */
 895  
     public DynamicURI setSecure()
 896  
     {
 897  0
         return setSecure(443);
 898  
     }
 899  
 
 900  
     /**
 901  
      * Method to specify that a URI should use SSL.  Whether or not it
 902  
      * does is determined from TurbineResources.properties.
 903  
      *
 904  
      * @param port An int with the port number.
 905  
      * @return A DynamicURI (self).
 906  
      */
 907  
     public DynamicURI setSecure(int port)
 908  
     {
 909  0
         boolean useSSL =
 910  
             Turbine.getConfiguration()
 911  
             .getBoolean(TurbineConstants.USE_SSL_KEY,
 912  
                         TurbineConstants.USE_SSL_DEFAULT);
 913  
 
 914  0
         setServerScheme(useSSL ? URIConstants.HTTPS : URIConstants.HTTP);
 915  0
         setServerPort(port);
 916  
 
 917  0
         return this;
 918  
     }
 919  
 
 920  
     /**
 921  
      * Sets the scheme (HTTP or HTTPS).
 922  
      *
 923  
      * @param scheme A String with the scheme.
 924  
      * @return A DynamicURI (self).
 925  
      */
 926  
     public DynamicURI setServerScheme(String scheme)
 927  
     {
 928  0
         getServerData().setServerScheme(scheme);
 929  0
         return this;
 930  
     }
 931  
 
 932  
     /**
 933  
      * Builds the URL with all of the data URL-encoded as well as
 934  
      * encoded using HttpServletResponse.encodeUrl().
 935  
      *
 936  
      * <p>
 937  
      * <code><pre>
 938  
      * DynamicURI dui = new DynamicURI (data, "UserScreen" );
 939  
      * dui.addPathInfo("user","jon");
 940  
      * dui.toString();
 941  
      * </pre></code>
 942  
      *
 943  
      *  The above call to toString() would return the String:
 944  
      *
 945  
      * <p>
 946  
      * http://www.server.com/servlets/Turbine/screen/UserScreen/user/jon
 947  
      *
 948  
      * @return A String with the built URL.
 949  
      */
 950  
     public String toString()
 951  
     {
 952  0
         assertInitialized();
 953  0
         StringBuffer output = new StringBuffer();
 954  0
         output.append(getServerScheme());
 955  0
         output.append(URIConstants.URI_SCHEME_SEPARATOR);
 956  0
         output.append(getServerName());
 957  0
         if ((getServerScheme().equals(URIConstants.HTTP)
 958  
                     && getServerPort() != URIConstants.HTTP_PORT)
 959  
                 || (getServerScheme().equals(URIConstants.HTTPS)
 960  
                     && getServerPort() != URIConstants.HTTPS_PORT)
 961  
         )
 962  
         {
 963  0
             output.append(":");
 964  0
             output.append(getServerPort());
 965  
         }
 966  0
         output.append(getContextPath());
 967  0
         output.append(getScriptName());
 968  0
         if (this.hasPathInfo)
 969  
         {
 970  0
             output.append("/");
 971  0
             output.append(renderPathInfo(this.pathInfo));
 972  
         }
 973  0
         if (this.hasQueryData)
 974  
         {
 975  0
             output.append("?");
 976  0
             output.append(renderQueryString(this.queryData));
 977  
         }
 978  0
         if (this.reference != null)
 979  
         {
 980  0
             output.append("#");
 981  0
             output.append(this.getReference());
 982  
         }
 983  
 
 984  
         // There seems to be a bug in Apache JServ 1.0 where the
 985  
         // session id is not appended to the end of the url when a
 986  
         // cookie has not been set.
 987  0
         if (this.res != null)
 988  
         {
 989  0
             if (this.redirect)
 990  0
                 return res.encodeRedirectURL(output.toString());
 991  
             else
 992  0
                 return res.encodeURL(output.toString());
 993  
         }
 994  
         else
 995  
         {
 996  0
             return output.toString();
 997  
         }
 998  
     }
 999  
 
 1000  
     /**
 1001  
      * Given a RunData object, get a URI for the request.  This is
 1002  
      * necessary sometimes when you want the exact URL and don't want
 1003  
      * DynamicURI to be too smart and remove actions, screens, etc.
 1004  
      * This also returns the Query Data where DynamicURI normally
 1005  
      * would not.
 1006  
      *
 1007  
      * @param data A Turbine RunData object.
 1008  
      * @return A String with the URL representing the RunData.
 1009  
      */
 1010  
     public static String toString(RunData data)
 1011  
     {
 1012  0
         StringBuffer output = new StringBuffer();
 1013  0
         HttpServletRequest request = data.getRequest();
 1014  
 
 1015  0
         output.append(data.getServerScheme());
 1016  0
         output.append(URIConstants.URI_SCHEME_SEPARATOR);
 1017  0
         output.append(data.getServerName());
 1018  
 
 1019  0
         if ((data.getServerScheme().equals(URIConstants.HTTP) &&
 1020  
                 data.getServerPort() != URIConstants.HTTP_PORT) ||
 1021  
                 (data.getServerScheme().equals(URIConstants.HTTPS) &&
 1022  
                 data.getServerPort() != URIConstants.HTTPS_PORT))
 1023  
         {
 1024  0
             output.append(":");
 1025  0
             output.append(data.getServerPort());
 1026  
         }
 1027  
 
 1028  0
         output.append(data.getServerData().getContextPath());
 1029  
 
 1030  0
         output.append(data.getServerData().getScriptName());
 1031  
 
 1032  0
         if (request.getPathInfo() != null)
 1033  
         {
 1034  0
             output.append(request.getPathInfo());
 1035  
         }
 1036  
 
 1037  0
         if (request.getQueryString() != null)
 1038  
         {
 1039  0
             output.append("?");
 1040  0
             output.append(request.getQueryString());
 1041  
         }
 1042  0
         return output.toString();
 1043  
     }
 1044  
 
 1045  
     /**
 1046  
      * Returns the ServerData used to initialize this DynamicURI.
 1047  
      *
 1048  
      * @return A ServerData used to initialize this DynamicURI.
 1049  
      */
 1050  
     public ServerData getServerData()
 1051  
     {
 1052  0
         assertInitialized();
 1053  0
         return this.sd;
 1054  
     }
 1055  
 
 1056  
     /**
 1057  
      * Sets the ServerData used to initialize this DynamicURI.
 1058  
      *
 1059  
      * @param serverData A ServerData used to initialize this DynamicURI.
 1060  
      * @deprecated no replacement.  This value is set during initialization
 1061  
      *             and should not be changed.
 1062  
      */
 1063  
     public void setServerData(ServerData serverData)
 1064  
     {
 1065  0
         this.sd = serverData;
 1066  0
     }
 1067  
 
 1068  
     /**
 1069  
      * Verifies that one of the init() methods has been called
 1070  
      */
 1071  
     protected void assertInitialized()
 1072  
     {
 1073  8
         if (!this.initialized)
 1074  
         {
 1075  0
             throw new IllegalStateException("Not initialized");
 1076  
         }
 1077  8
     }
 1078  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.