* JBoss, a division of Red Hat

* Copyright 2010, Red Hat Middleware, LLC, and individual

* contributors as indicated by the @authors tag. See the

* copyright.txt in the distribution for a full listing of

* individual contributors.

*

* This is free software; you can redistribute it and/or modify it

* under the terms of the GNU Lesser General Public License as

* published by the Free Software Foundation; either version 2.1 of

* the License, or (at your option) any later version.

*

* This software is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this software; if not, write to the Free

* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

* 02110-1301 USA, or see the FSF site: http://www.fsf.org.

*/

* <p/>

* Creates minimally valid instances of WSRP types, populated with default values where possible, as per

* wsrp_v2_types.xsd.

*

* @author <a href="mailto:chris.laprun@jboss.com">Chris Laprun</a>

* @version $Revision: 11317 $

* @since 2.4

*/

   private static final String AMP = "&";

   private static final String EQ = "=";

   private static final String ADDITIONAL_RESOURCE_URL_PARAMS = AMP + RESOURCE_REQUIRES_REWRITE + EQ

      + WSRP_REQUIRES_REWRITE + AMP + WSRPRewritingConstants.RESOURCE_URL + EQ + REWRITE_PARAMETER_OPEN

      + WSRPRewritingConstants.RESOURCE_URL + REWRITE_PARAMETER_CLOSE + AMP

      + WSRP2RewritingConstants.RESOURCE_PREFER_OPERATION + EQ + REWRITE_PARAMETER_OPEN

      + WSRP2RewritingConstants.RESOURCE_PREFER_OPERATION + REWRITE_PARAMETER_CLOSE;

   private static final OpaqueStateString WSRP_NAVIGATIONAL_STATE_TOKEN = new OpaqueStateString(REWRITE_PARAMETER_OPEN + NAVIGATIONAL_STATE + REWRITE_PARAMETER_CLOSE);

   private static final WindowState WSRP_WINDOW_STATE_TOKEN = WindowState.create(REWRITE_PARAMETER_OPEN + WINDOW_STATE + REWRITE_PARAMETER_CLOSE, true);

   private static final Mode WSRP_MODE_TOKEN = Mode.create(REWRITE_PARAMETER_OPEN + MODE + REWRITE_PARAMETER_CLOSE, true);

   private WSRPTypeFactory()

   {

   }

   /** ====== WSRP request objects ====== **/

   /**

    * registrationContext(RegistrationContext, nillable), desiredLocales(xsd:string)*, portletHandles(xsd:string)*,

    * userContext(UserContext, nillable)

    *

    * @param registrationContext can be null

    * @param userContext         can be null

    * @return

    */

   public static GetServiceDescription createGetServiceDescription(RegistrationContext registrationContext, UserContext userContext)

   {

      GetServiceDescription getServiceDescription = new GetServiceDescription();

      getServiceDescription.setRegistrationContext(registrationContext);

      getServiceDescription.setUserContext(userContext);

      return getServiceDescription;

   }

   /**

    * {@link RegistrationContext} (nillable), {@link PortletContext}, {@link RuntimeContext}, {@link UserContext}

    * (nillable), {@link MarkupParams}

    *

    * @param registrationContext can be null

    * @param portletContext

    * @param runtimeContext

    * @param userContext         can be null

    * @param markupParams

    * @return

    * @throws IllegalArgumentException if one of the required, non-nillable parameters is <code>null</code>

    */

   public static GetMarkup createGetMarkup(RegistrationContext registrationContext, PortletContext portletContext, RuntimeContext runtimeContext, UserContext userContext, MarkupParams markupParams)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "PortletContext");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(portletContext.getPortletHandle(), "portlet handle", "PortletContext");

      ParameterValidation.throwIllegalArgExceptionIfNull(runtimeContext, "RuntimeContext");

      ParameterValidation.throwIllegalArgExceptionIfNull(markupParams, "MarkupParams");

      GetMarkup getMarkup = new GetMarkup();

      getMarkup.setRegistrationContext(registrationContext);

      getMarkup.setPortletContext(portletContext);

      getMarkup.setRuntimeContext(runtimeContext);

      getMarkup.setUserContext(userContext);

      getMarkup.setMarkupParams(markupParams);

      return getMarkup;

   }

   /**

    * {@link RegistrationContext} (nillable), {@link PortletContext}, {@link RuntimeContext}, {@link UserContext}

    * (nillable), {@link ResourceParams}

    *

    * @param registrationContext can be null

    * @param portletContext

    * @param runtimeContext

    * @param userContext         can be null

    * @param resourceParams

    * @return

    * @throws IllegalArgumentException if one of the required, non-nillable parameters is <code>null</code>

    */

   public static GetResource createGetResource(RegistrationContext registrationContext, PortletContext portletContext, RuntimeContext runtimeContext, UserContext userContext, ResourceParams resourceParams)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "PortletContext");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(portletContext.getPortletHandle(), "portlet handle", "PortletContext");

      ParameterValidation.throwIllegalArgExceptionIfNull(runtimeContext, "RuntimeContext");

      ParameterValidation.throwIllegalArgExceptionIfNull(resourceParams, "ResourceParams");

      GetResource getResource = new GetResource();

      getResource.setRegistrationContext(registrationContext);

      getResource.setPortletContext(portletContext);

      getResource.setRuntimeContext(runtimeContext);

      getResource.setUserContext(userContext);

      getResource.setResourceParams(resourceParams);

      return getResource;

   }

   /**

    * {@link RegistrationContext} (nillable), {@link PortletContext}, {@link RuntimeContext}, {@link UserContext}

    * (nillable), {@link MarkupParams}, {@link InteractionParams}

    *

    * @param registrationContext can be null

    * @param portletContext

    * @param runtimeContext

    * @param userContext         can be null

    * @param markupParams

    * @param interactionParams

    * @return

    * @throws IllegalArgumentException if one of the required, non-nillable parameters is <code>null</code>

    */

   public static PerformBlockingInteraction createPerformBlockingInteraction(

      RegistrationContext registrationContext, PortletContext portletContext, RuntimeContext runtimeContext,

      UserContext userContext, MarkupParams markupParams,

      InteractionParams interactionParams)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "PortletContext");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(portletContext.getPortletHandle(), "portlet handle", "PortletContext");

      ParameterValidation.throwIllegalArgExceptionIfNull(runtimeContext, "RuntimeContext");

      ParameterValidation.throwIllegalArgExceptionIfNull(markupParams, "MarkupParams");

      ParameterValidation.throwIllegalArgExceptionIfNull(interactionParams, "InteractionParams");

      PerformBlockingInteraction performBlockingInteraction = new PerformBlockingInteraction();

      performBlockingInteraction.setRegistrationContext(registrationContext);

      performBlockingInteraction.setPortletContext(portletContext);

      performBlockingInteraction.setRuntimeContext(runtimeContext);

      performBlockingInteraction.setUserContext(userContext);

      performBlockingInteraction.setMarkupParams(markupParams);

      performBlockingInteraction.setInteractionParams(interactionParams);

      return performBlockingInteraction;

   }

   /**

    * {@link RegistrationContext} (nillable), {@link PortletContext}, {@link RuntimeContext}, {@link UserContext}

    * (nillable), {@link MarkupParams}, {@link EventParams}

    *

    * @param registrationContext can be null

    * @param portletContext

    * @param runtimeContext

    * @param userContext         can be null

    * @param markupParams

    * @param eventParams

    * @return

    */

   public static HandleEvents createHandleEvents(RegistrationContext registrationContext, PortletContext portletContext, RuntimeContext runtimeContext,

                                                 UserContext userContext, MarkupParams markupParams, EventParams eventParams)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "PortletContext");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(portletContext.getPortletHandle(), "portlet handle", "PortletContext");

      ParameterValidation.throwIllegalArgExceptionIfNull(runtimeContext, "RuntimeContext");

      ParameterValidation.throwIllegalArgExceptionIfNull(markupParams, "MarkupParams");

      ParameterValidation.throwIllegalArgExceptionIfNull(eventParams, "EventParams");

      HandleEvents handleEvents = new HandleEvents();

      handleEvents.setRegistrationContext(registrationContext);

      handleEvents.setPortletContext(portletContext);

      handleEvents.setRuntimeContext(runtimeContext);

      handleEvents.setUserContext(userContext);

      handleEvents.setMarkupParams(markupParams);

      handleEvents.setEventParams(eventParams);

      return handleEvents;

   }

   /**

    * registrationContext(RegistrationContext)?, portletContext(PortletContext), userContext(UserContext)?,

    * desiredLocales(xsd:string)*

    *

    * @param registrationContext

    * @param portletHandle       handle for the PortletContext

    * @return

    * @since 2.4.1

    */

   public static GetPortletDescription createGetPortletDescription(RegistrationContext registrationContext, String portletHandle)

   {

      PortletContext portletContext = createPortletContext(portletHandle);

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "portlet context");

      GetPortletDescription description = new GetPortletDescription();

      description.setPortletContext(portletContext);

      description.setRegistrationContext(registrationContext);

      return description;

   }

   public static GetPortletDescription createGetPortletDescription(RegistrationContext registrationContext, PortletContext portletContext, UserContext userContext)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "portlet context");

      GetPortletDescription description = new GetPortletDescription();

      description.setPortletContext(portletContext);

      description.setRegistrationContext(registrationContext);

      description.setUserContext(userContext);

      return description;

   }

   /**

    * @param registrationContext

    * @param portletContext

    * @return

    * @since 2.6

    */

   public static GetPortletDescription createGetPortletDescription(RegistrationContext registrationContext,

                                                                   org.gatein.pc.api.PortletContext portletContext)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "portlet context");

      PortletContext wsrpPC = createPortletContext(portletContext.getId());

      if (portletContext instanceof StatefulPortletContext)

      {

         StatefulPortletContext context = (StatefulPortletContext)portletContext;

         if (PortletStateType.OPAQUE.equals(context.getType()))

         {

            wsrpPC.setPortletState(((StatefulPortletContext<byte[]>)context).getState());

         }

      }

      GetPortletDescription getPortletDescription = new GetPortletDescription();

      getPortletDescription.setRegistrationContext(registrationContext);

      getPortletDescription.setPortletContext(wsrpPC);

      return getPortletDescription;

   }

   public static GetPortletProperties createGetPortletProperties(RegistrationContext registrationContext, PortletContext portletContext, UserContext userContext, List<String> names)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "PortletContext");

      GetPortletProperties properties = new GetPortletProperties();

      properties.setRegistrationContext(registrationContext);

      properties.setPortletContext(portletContext);

      properties.setUserContext(userContext);

      properties.getNames().addAll(names);

      return properties;

   }

   /** ====== WSRP Response objects ====== * */

   public static BlockingInteractionResponse createBlockingInteractionResponse(UpdateResponse updateResponse)

   {

      if (updateResponse == null)

      {

         throw new IllegalArgumentException("BlockingInteractionResponse requires either an UpdateResponse or a redirect URL.");

      }

      BlockingInteractionResponse interactionResponse = new BlockingInteractionResponse();

      interactionResponse.setUpdateResponse(updateResponse);

      return interactionResponse;

   }

   public static BlockingInteractionResponse createBlockingInteractionResponse(String redirectURL)

   {

      if (redirectURL == null || redirectURL.length() == 0)

      {

         throw new IllegalArgumentException("BlockingInteractionResponse requires either an UpdateResponse or a redirect URL.");

      }

      BlockingInteractionResponse interactionResponse = new BlockingInteractionResponse();

      interactionResponse.setRedirectURL(redirectURL);

      return interactionResponse;

   }

   public static UpdateResponse createUpdateResponse()

   {

      return new UpdateResponse();

   }

   public static PortletDescription createPortletDescription(String portletHandle, List<MarkupType> markupTypes)

   {

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(portletHandle, "portlet handle", null);

      checkPortletHandle(portletHandle);

      ParameterValidation.throwIllegalArgExceptionIfNull(markupTypes, "MarkupType");

      if (markupTypes.isEmpty())

      {

         throw new IllegalArgumentException("Cannot create a PortletDescription with an empty list of MarkupTypes!");

      }

      PortletDescription portletDescription = new PortletDescription();

      portletDescription.setPortletHandle(portletHandle);

      portletDescription.getMarkupTypes().addAll(markupTypes);

      return portletDescription;

   }

   private static void checkPortletHandle(String portletHandle)

   {

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(portletHandle, "portlet handle", null);

      if (portletHandle.length() > 255)

      {

         throw new IllegalArgumentException("Portlet handles must be less than 255 characters long. Was "

            + portletHandle.length() + " long.");

      }

   }

   public static MarkupParams createMarkupParams(boolean secureClientCommunication, List<String> locales,

                                                 List<String> mimeTypes, String mode, String windowState)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(locales, "locales");

      if (locales.isEmpty())

      {

         throw new IllegalArgumentException("Cannot create a MarkupParams with an empty list of locales!");

      }

      if (mimeTypes.isEmpty())

      {

         throw new IllegalArgumentException("Cannot create a MarkupParams with an empty list of mimeTypes!");

      }

      ParameterValidation.throwIllegalArgExceptionIfNull(mimeTypes, "MIME types");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(mode, "mode", "MarkupParams");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(windowState, "window state", "MarkupParams");

      MarkupParams markupParams = new MarkupParams();

      markupParams.setSecureClientCommunication(secureClientCommunication);

      markupParams.setMode(mode);

      markupParams.setWindowState(windowState);

      if (ParameterValidation.existsAndIsNotEmpty(locales))

      {

         markupParams.getLocales().addAll(locales);

      }

      if (ParameterValidation.existsAndIsNotEmpty(mimeTypes))

      {

         markupParams.getMimeTypes().addAll(mimeTypes);

      }

      return markupParams;

   }

   public static ResourceParams createDefaultResourceParams(String resourceID)

   {

      return createResourceParams(false, WSRPConstants.getDefaultLocales(), WSRPConstants.getDefaultMimeTypes(),

         WSRPConstants.VIEW_MODE, WSRPConstants.NORMAL_WINDOW_STATE, resourceID, StateChange.READ_ONLY);

   }

   public static ResourceParams createResourceParams(boolean secureClientCommunication, List<String> locales, List<String> mimeTypes, String mode, String windowState, String resourceID, StateChange stateChange, Map<String, String[]> parameters)

   {

      ResourceParams resourceParams = createResourceParams(secureClientCommunication, locales, mimeTypes, mode, windowState, resourceID, stateChange);

      List<NamedString> formParameters = new ArrayList<NamedString>(parameters.size());

      for (String key : parameters.keySet())

      {

         NamedString namedString = new NamedString();

         namedString.setName(key);

         namedString.setValue(parameters.get(key)[0]);

         resourceParams.getFormParameters().add(namedString);

      }

      return resourceParams;

   }

   public static ResourceParams createResourceParams(boolean secureClientCommunication, List<String> locales, List<String> mimeTypes, String mode, String windowState, String resourceID, StateChange stateChange)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(locales, "locales");

      if (locales.isEmpty())

      {

         throw new IllegalArgumentException("Cannot create a ResourceParams with an empty list of locales!");

      }

      ParameterValidation.throwIllegalArgExceptionIfNull(mimeTypes, "locales");

      if (mimeTypes.isEmpty())

      {

         throw new IllegalArgumentException("Cannot create a MarkupParams with an empty list of mimeTypes!");

      }

      ParameterValidation.throwIllegalArgExceptionIfNull(mimeTypes, "MIME types");

      ParameterValidation.throwIllegalArgExceptionIfNull(stateChange, "State Change");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(mode, "mode", "ResourceParams");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(windowState, "window state", "ResourceParams");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(resourceID, "Resource ID", "ResourceParams");

      ResourceParams resourceParams = new ResourceParams();

      resourceParams.setSecureClientCommunication(secureClientCommunication);

      resourceParams.setMode(mode);

      resourceParams.setWindowState(windowState);

      if (ParameterValidation.existsAndIsNotEmpty(locales))

      {

         resourceParams.getLocales().addAll(locales);

      }

      if (ParameterValidation.existsAndIsNotEmpty(mimeTypes))

      {

         resourceParams.getMimeTypes().addAll(mimeTypes);

      }

      resourceParams.setResourceID(resourceID);

      resourceParams.setPortletStateChange(stateChange);

      return resourceParams;

   }

   public static RuntimeContext createRuntimeContext(String userAuthentication, String portletInstanceKey, String namespacePrefix)

   {

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(userAuthentication, "user authentication", "RuntimeContext");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(portletInstanceKey, "Portlet Instance Key", "RuntimeContext");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(namespacePrefix, "Namespace Prefix", "RuntimeContext");

      RuntimeContext runtimeContext = new RuntimeContext();

      runtimeContext.setUserAuthentication(userAuthentication);

      runtimeContext.setPortletInstanceKey(portletInstanceKey);

      runtimeContext.setNamespacePrefix(namespacePrefix);

      return runtimeContext;

   }

   public static PortletContext createPortletContext(String portletHandle)

   {

      checkPortletHandle(portletHandle);

      PortletContext portletContext = new PortletContext();

      portletContext.setPortletHandle(portletHandle);

      return portletContext;

   }

   public static PortletContext createPortletContext(String portletHandle, byte[] portletState)

   {

      PortletContext pc = createPortletContext(portletHandle);

      pc.setPortletState(portletState);

      return pc;

   }

   public static InteractionParams createInteractionParams(StateChange portletStateChange)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletStateChange, "portletStateChange");

      InteractionParams interactionParams = new InteractionParams();

      interactionParams.setPortletStateChange(portletStateChange);

      return interactionParams;

   }

   public static InitCookie createInitCookie(RegistrationContext registrationContext)

   {

      InitCookie initCookie = new InitCookie();

      initCookie.setRegistrationContext(registrationContext);

      return initCookie;

   }

   public static ServiceDescription createServiceDescription(boolean requiresRegistration)

   {

      ServiceDescription serviceDescription = new ServiceDescription();

      serviceDescription.setRequiresRegistration(requiresRegistration);

      return serviceDescription;

   }

   public static MarkupResponse createMarkupResponse(MarkupContext markupContext)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(markupContext, "MarkupContext");

      MarkupResponse markupResponse = new MarkupResponse();

      markupResponse.setMarkupContext(markupContext);

      return markupResponse;

   }

   public static ResourceResponse createResourceResponse(ResourceContext resourceContext)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(resourceContext, "ResourceContext");

      ResourceResponse resourceResponse = new ResourceResponse();

      resourceResponse.setResourceContext(resourceContext);

      return resourceResponse;

   }

   /**

    * mimeType: The mime type of the returned markup. The mimeType field MUST be specified whenever markup is returned,

    * and if the markupBinary field is used to return the markup, the mime type MUST include the character set for

    * textual mime types using the syntax specified in RFC1522[14] (e.g. "text/html; charset=UTF-8"). In this

    * particular case this character set MAY be different than the response message.

    */

   public static MarkupContext createMarkupContext(String mediaType, String markupString, byte[] markupBinary, Boolean useCachedItem)

   {

      boolean isUseCachedItem = (useCachedItem != null) && useCachedItem.booleanValue();

      MarkupContext markupContext = new MarkupContext();

      markupContext.setMimeType(mediaType);

      if (isUseCachedItem)

      {

         markupContext.setUseCachedItem(useCachedItem);

      }

      else

      {

         ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(mediaType, "Media type", "MarkupContext");

         if (markupBinary != null)

         {

            markupContext.setItemBinary(markupBinary);

         }

         else if (markupString != null)

         {

            markupContext.setItemString(markupString);

         }

         else

         {

            throw new IllegalArgumentException("MarkupContext required either a true useCacheItem or a non-null markup string or binary markup");

         }

      }

      return markupContext;

   }

   /**

    * @param mediaType The mime type of the returned resource. The mimeType field MUST be specified whenever resource

    *                  is returned, and if the resourceBinary field is used to return the resource, the mime type MUST

    *                  include the character set for textual mime types using the syntax specified in RFC1522[14] (e.g.

    *                  "text/html; charset=UTF-8"). In this particular case this character set MAY be different than

    *                  the response message.

    * @return a new ResourceContext

    */

   public static ResourceContext createResourceContext(String mediaType, String resourceString, byte[] resourceBinary)

   {

      return createMimeResponse(mediaType, resourceString, resourceBinary, ResourceContext.class);

   }

   public static <T extends MimeResponse> T createMimeResponse(String mimeType, String itemString, byte[] itemBinary, Class<T> clazz)

   {

      if ((itemString == null) && (itemBinary == null || itemBinary.length == 0))

      {

         throw new IllegalArgumentException("MimeResponse requires either a non-null markup string or binary markup.");

      }

      T mimeResponse;

      try

      {

         mimeResponse = clazz.newInstance();

      }

      catch (Exception e)

      {

         throw new RuntimeException("Couldn't instantiate " + clazz.getSimpleName(), e);

      }

      mimeResponse.setMimeType(mimeType);

      if (itemString != null)

      {

         mimeResponse.setItemString(itemString);

      }

      else

      {

         mimeResponse.setItemBinary(itemBinary);

      }

      return mimeResponse;

   }

   /**

    * @param sessionID An opaque string the Portlet defines for referencing state that is stored locally on the

    *                  Producer. The maximum length of a sessionID is 4096 characters,

    * @param expires   Maximum number of seconds between invocations referencing the sessionID before the Producer will

    *                  schedule releasing the related resources. A value of -1 indicates that the sessionID will never

    *                  expire.

    * @return a new SessionContext

    */

   public static SessionContext createSessionContext(String sessionID, int expires)

   {

      if (expires < 0)

      {

         throw new IllegalArgumentException("SessionContext requires a positive expiration time.");

      }

      SessionContext sessionContext = new SessionContext();

      sessionContext.setSessionID(sessionID);

      sessionContext.setExpires(expires);

      return sessionContext;

   }

   /** For UserProfile and related classes, everything is optional so no need to have factory methods. */

   public static UserContext createUserContext(String userContextKey)

   {

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(userContextKey, "user context key", "UserContext");

      UserContext userContext = new UserContext();

      userContext.setUserContextKey(userContextKey);

      return userContext;

   }

   /**

    * @param consumerName       A name (preferably unique) that identifies the Consumer [R355] An example of such a

    *                           name would be the Consumer's URL.

    * @param methodGetSupported A flag that tells the Producer whether the Consumer has implemented portlet URLs

    *                           (regardless of whether they are written through Consumer URL rewriting or Producer URL

    *                           writing, see [Section 10.2]) in a manner that supports HTML markup containing forms

    *                           with method="get".

    * @return

    */

   public static RegistrationData createRegistrationData(String consumerName, String consumerAgent, boolean methodGetSupported)

   {

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(consumerName, "consumer name", "RegistrationData");

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(consumerAgent, "consumer agent", "RegistrationData");

      RegistrationData regData = createDefaultRegistrationData();

      regData.setConsumerName(consumerName);

      regData.setConsumerAgent(consumerAgent);

      regData.setMethodGetSupported(methodGetSupported);

      return regData;

   }

   /**

    * Same as createRegistrationData({@link WSRPConstants#DEFAULT_CONSUMER_NAME}, false) using

    * {@link WSRPConstants#CONSUMER_AGENT} for the consumer agent.

    *

    * @return

    * @since 2.4.1

    */

   public static RegistrationData createDefaultRegistrationData()

   {

      RegistrationData registrationData = new RegistrationData();

      registrationData.setConsumerName(WSRPConstants.DEFAULT_CONSUMER_NAME);

      registrationData.setConsumerAgent(WSRPConstants.CONSUMER_AGENT);

      registrationData.setMethodGetSupported(false);

      return registrationData;

   }

   public static Property createProperty(String name, String lang, String stringValue)

   {

      // QName.valueOf validates name

      QName qName = QName.valueOf(name);

      return createProperty(qName, lang, stringValue);

   }

   public static Property createProperty(QName name, String lang, String stringValue)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(name, "name");

      Property property = new Property();

      property.setName(name);

      if (!ParameterValidation.isNullOrEmpty(lang))

      {

         property.setLang(lang);

      }

      property.setStringValue(stringValue);

      return property;

   }

   private static final OpaqueStateString WSRP_INTERACTION_STATE_TOKEN = new OpaqueStateString(REWRITE_PARAMETER_OPEN + INTERACTION_STATE + REWRITE_PARAMETER_CLOSE);

   private static final ActionURL ACTION_URL = new ActionURL()

   {

      public StateString getInteractionState()

      {

         return WSRP_INTERACTION_STATE_TOKEN;

      }

      public StateString getNavigationalState()

      {

         return getTemplateNS();

      }

      public Mode getMode()

      {

         return getTemplateMode();

      }

      public WindowState getWindowState()

      {

         return getTemplateWindowState();

      }

      public Map<String, String> getProperties()

      {

         return Collections.emptyMap();

      }

   };

   private static final HashMap<String, String[]> WSRP_PNS_MAP_TOKEN = new HashMap<String, String[]>();

   static

   {

      WSRP_PNS_MAP_TOKEN.put(WSRP2RewritingConstants.NAVIGATIONAL_VALUES,

         new String[]{REWRITE_PARAMETER_OPEN + WSRP2RewritingConstants.NAVIGATIONAL_VALUES + REWRITE_PARAMETER_CLOSE});

   }

   private static final RenderURL RENDER_URL = new RenderURL()

   {

      public StateString getNavigationalState()

      {

         return getTemplateNS();

      }

      public Map<String, String[]> getPublicNavigationalStateChanges()

      {

         return WSRP_PNS_MAP_TOKEN;

      }

      public Mode getMode()

      {

         return getTemplateMode();

      }

      public WindowState getWindowState()

      {

         return getTemplateWindowState();

      }

      public Map<String, String> getProperties()

      {

         return Collections.emptyMap();

      }

   };

   private static final OpaqueStateString WSRP_RESOURCE_STATE_TOKEN = new OpaqueStateString(REWRITE_PARAMETER_OPEN + WSRP2RewritingConstants.RESOURCE_STATE + REWRITE_PARAMETER_CLOSE);

   private static ResourceURL RESOURCE_URL = new ResourceURL()

   {

      public String getResourceId()

      {

         return REWRITE_PARAMETER_OPEN + WSRP2RewritingConstants.RESOURCE_ID + REWRITE_PARAMETER_CLOSE;

      }

      public StateString getResourceState()

      {

         return WSRP_RESOURCE_STATE_TOKEN;

      }

      public CacheLevel getCacheability()

      {

         return CacheLevel.create(REWRITE_PARAMETER_OPEN + WSRP2RewritingConstants.RESOURCE_CACHEABILITY + REWRITE_PARAMETER_CLOSE);

      }

      public Mode getMode()

      {

         return getTemplateMode();

      }

      public WindowState getWindowState()

      {

         return getTemplateWindowState();

      }

      public StateString getNavigationalState()

      {

         return getTemplateNS();

      }

      public Map<String, String> getProperties()

      {

         return Collections.emptyMap();

      }

   };

   private static StateString getTemplateNS()

   {

      return WSRP_NAVIGATIONAL_STATE_TOKEN;

   }

   private static WindowState getTemplateWindowState()

   {

      return WSRP_WINDOW_STATE_TOKEN;

   }

   private static Mode getTemplateMode()

   {

      return WSRP_MODE_TOKEN;

   }

   /**

    * defaultTemplate(xsd:string)?, blockingActionTemplate(xsd:string)?, renderTemplate(xsd:string)?,

    * resourceTemplate(xsd:string)?, secureDefaultTemplate(xsd:string)?, secureBlockingActionTemplate(xsd:string)?,

    * secureRenderTemplate(xsd:string)?, secureResourceTemplate(xsd:string)?, extensions(Extension)*

    *

    * @param context

    * @return

    */

   public static Templates createTemplates(PortletInvocationContext context)

   {

      Templates templates = new Templates();

      templates.setBlockingActionTemplate(createTemplate(context, ACTION_URL, Boolean.FALSE));

      templates.setRenderTemplate(createTemplate(context, RENDER_URL, Boolean.FALSE));

      templates.setSecureBlockingActionTemplate(createTemplate(context, ACTION_URL, Boolean.TRUE));

      templates.setSecureRenderTemplate(createTemplate(context, RENDER_URL, Boolean.TRUE));

      templates.setResourceTemplate(createTemplate(context, RESOURCE_URL, false));

      templates.setSecureResourceTemplate(createTemplate(context, RESOURCE_URL, true));

      return templates;

   }

   public static Templates createTemplates(String defaultTemplate, String blockingActionTemplate, String renderTemplate, String resourceTemplate, String secureDefaultTemplate, String secureBlockingActionTemplate, String secureRenderTemplate, String secureResourceTemplate)

   {

      Templates templates = new Templates();

      templates.setDefaultTemplate(defaultTemplate);

      templates.setBlockingActionTemplate(blockingActionTemplate);

      templates.setRenderTemplate(renderTemplate);

      templates.setResourceTemplate(resourceTemplate);

      templates.setSecureDefaultTemplate(secureDefaultTemplate);

      templates.setSecureBlockingActionTemplate(secureBlockingActionTemplate);

      templates.setSecureRenderTemplate(secureRenderTemplate);

      templates.setSecureResourceTemplate(secureResourceTemplate);

      return templates;

   }

   private static String createTemplate(PortletInvocationContext context, ContainerURL url, Boolean secure)

   {

      String template = context.renderURL(url, new URLFormat(secure, null, null, true));

      template = TextTools.replace(template, WSRPRewritingConstants.ENC_OPEN, WSRPRewritingConstants.REWRITE_PARAMETER_OPEN);

      template = TextTools.replace(template, WSRPRewritingConstants.ENC_CLOSE, WSRPRewritingConstants.REWRITE_PARAMETER_CLOSE);

      // fix for GTNWSRP-22

      if (RESOURCE_URL.equals(url))

      {

         template += ADDITIONAL_RESOURCE_URL_PARAMS;

      }

      return template;

   }

   /**

    * userAgent(xsd:string)?, extensions(Extension)*

    *

    * @param userAgent

    * @return

    */

   public static ClientData createClientData(String userAgent)

   {

      ClientData clientData = new ClientData();

      clientData.setUserAgent(userAgent);

      return clientData;

   }

   /**

    * userAgent(xsd:string)?, requestVerb(xsd:string)?, extensions(Extension)*

    *

    * @param userAgent

    * @param requestVerb

    * @return

    */

   public static ClientData createClientData(String userAgent, String requestVerb)

   {

      ClientData clientData = createClientData(userAgent);

      clientData.setRequestVerb(requestVerb);

      return clientData;

   }

   /**

    * expires(xsd:int), userScope(xsd:string), validateTag(xsd:string)?, extensions(Extension)*

    *

    * @param expires   Number of seconds the markup fragment referenced by this cache control entry remains valid. A

    *                  value of -1 indicates that the markup fragment will never expire.

    * @param userScope

    * @return

    */

   public static CacheControl createCacheControl(int expires, String userScope)

   {

      ParameterValidation.throwIllegalArgExceptionIfNullOrEmpty(userScope, "user scope", "CacheControl");

      if (expires < -1)

      {

         throw new IllegalArgumentException("Cache expiration time must be greater than -1, " +

            "-1 indicating that the cache will never expire.");

      }

      CacheControl cacheControl = new CacheControl();

      cacheControl.setExpires(expires);

      cacheControl.setUserScope(userScope);

      return cacheControl;

   }

   /**

    * registrationHandle(xsd:string), registrationState(xsd:base64Binary)?, extensions(Extension)*

    *

    * @param registrationHandle

    * @return

    * @since 2.4.1

    */

   public static RegistrationContext createRegistrationContext(String registrationHandle)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(registrationHandle, "Registration handle");

      RegistrationContext registrationContext = new RegistrationContext();

      registrationContext.setRegistrationHandle(registrationHandle);

      return registrationContext;

   }

   /**

    * propertyDescriptions(PropertyDescription)*, modelTypes(ModelTypes)?, extensions(Extension)*

    *

    * @return

    * @since 2.6

    */

   public static ModelDescription createModelDescription(List<PropertyDescription> propertyDescriptions)

   {

      ModelDescription description = new ModelDescription();

      if (ParameterValidation.existsAndIsNotEmpty(propertyDescriptions))

      {

         description.getPropertyDescriptions().addAll(propertyDescriptions);

      }

      return description;

   }

   /**

    * label(LocalizedString)?, hint(LocalizedString)?, extensions(Extension)*, @name(xsd:string), @type(xsd:QName)

    *

    * @return

    * @since 2.6

    */

   public static PropertyDescription createPropertyDescription(String name, QName type)

   {

      // QName.valueOf(name) validates name

      QName qName = QName.valueOf(name);

      ParameterValidation.throwIllegalArgExceptionIfNull(type, "PropertyDescription type");

      PropertyDescription description = new PropertyDescription();

      description.setName(qName);

      description.setType(type);

      return description;

   }

   /**

    * value(xsd:string), @xml:lang, @resourceName(xsd:string)?

    *

    * @return

    * @since 2.6

    */

   public static LocalizedString createLocalizedString(String lang, String resourceName, String value)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(lang, "LocalizedString language");

      ParameterValidation.throwIllegalArgExceptionIfNull(value, "LocalizedString value");

      LocalizedString localizedString = new LocalizedString();

      localizedString.setLang(lang);

      localizedString.setResourceName(resourceName);

      localizedString.setValue(value);

      return localizedString;

   }

   /**

    * Same as createLocalizedString("en", null, value)

    *

    * @param value

    * @return

    * @since 2.6

    */

   public static LocalizedString createLocalizedString(String value)

   {

      return createLocalizedString("en", null, value);

   }

   /**

    * portletDescription(PortletDescription), resourceList(ResourceList)?, extensions(Extension)*

    *

    * @param portletDescription

    * @return

    * @since 2.6

    */

   public static PortletDescriptionResponse createPortletDescriptionResponse(PortletDescription portletDescription)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletDescription, "PortletDescription");

      PortletDescriptionResponse response = new PortletDescriptionResponse();

      response.setPortletDescription(portletDescription);

      return response;

   }

   /**

    * modelDescription(ModelDescription)?, resourceList(ResourceList)?, extensions(Extension)*

    *

    * @param propertyDescriptions

    * @return

    * @since 2.6

    */

   public static PortletPropertyDescriptionResponse createPortletPropertyDescriptionResponse(List<PropertyDescription> propertyDescriptions)

   {

      ModelDescription modelDescription = propertyDescriptions == null ? null : createModelDescription(propertyDescriptions);

      PortletPropertyDescriptionResponse portletPropertyDescriptionResponse = new PortletPropertyDescriptionResponse();

      portletPropertyDescriptionResponse.setModelDescription(modelDescription);

      return portletPropertyDescriptionResponse;

   }

   /**

    * registrationContext(RegistrationContext)?, portletContext(PortletContext), userContext(UserContext)?,

    * desiredLocales(xsd:string)*

    *

    * @return

    * @since 2.6

    */

   public static GetPortletPropertyDescription createGetPortletPropertyDescription(RegistrationContext registrationContext,

                                                                                   PortletContext portletContext,

                                                                                   UserContext userContext, List<String> desiredLocales)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "PortletContext");

      GetPortletPropertyDescription description = new GetPortletPropertyDescription();

      description.setRegistrationContext(registrationContext);

      description.setPortletContext(portletContext);

      description.setUserContext(userContext);

      if (ParameterValidation.existsAndIsNotEmpty(desiredLocales))

      {

         description.getDesiredLocales().addAll(desiredLocales);

      }

      return description;

   }

   /**

    * Same as createGetPortletPropertyDescription(null, createPortletContext(portletHandle), null, null)

    *

    * @param portletHandle

    * @return

    * @since 2.6

    */

   public static GetPortletPropertyDescription createSimpleGetPortletPropertyDescription(String portletHandle)

   {

      return createGetPortletPropertyDescription(null, createPortletContext(portletHandle), null, null);

   }

   /**

    * registrationContext(RegistrationContext)?, portletContext(PortletContext), userContext(UserContext)?,

    * propertyList(PropertyList)

    *

    * @param portletContext

    * @param propertyList

    * @return

    * @since 2.6

    */

   public static SetPortletProperties createSetPortletProperties(

      RegistrationContext registrationContext,

      PortletContext portletContext,

      PropertyList propertyList)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "PortletContext");

      ParameterValidation.throwIllegalArgExceptionIfNull(propertyList, "PropertyList");

      SetPortletProperties properties = new SetPortletProperties();

      properties.setRegistrationContext(registrationContext);

      properties.setPortletContext(portletContext);

      properties.setPropertyList(propertyList);

      return properties;

   }

   /**

    * same as createClonePortlet(null, createPortletContext(portletHandle), null)

    *

    * @param portletHandle

    * @return

    * @since 2.6

    */

   public static ClonePortlet createSimpleClonePortlet(String portletHandle)

   {

      return createClonePortlet(null, createPortletContext(portletHandle), null);

   }

   /**

    * registrationContext(RegistrationContext)?, portletContext(PortletContext), userContext(UserContext)?

    *

    * @return

    * @since 2.6

    */

   public static ClonePortlet createClonePortlet(RegistrationContext registrationContext, PortletContext portletContext, UserContext userContext)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletContext, "PortletContext");

      ClonePortlet clonePortlet = new ClonePortlet();

      clonePortlet.setPortletContext(portletContext);

      clonePortlet.setRegistrationContext(registrationContext);

      clonePortlet.setUserContext(userContext);

      return clonePortlet;

   }

   public static DestroyPortlets createDestroyPortlets(RegistrationContext registrationContext, List<String> portletHandles)

   {

      ParameterValidation.throwIllegalArgExceptionIfNull(portletHandles, "Portlet handles");

      if (!ParameterValidation.existsAndIsNotEmpty(portletHandles))

      {

         throw new IllegalArgumentException("Cannot create a DestroyPortlets with an empty list of portlet handles!");

      }

      DestroyPortlets destroyPortlets = new DestroyPortlets();

      destroyPortlets.setRegistrationContext(registrationContext);

      destroyPortlets.getPortletHandles().addAll(portletHandles);

      return destroyPortlets;

   }

   /**

    * properties(Property)*, resetProperties(ResetProperty)*, extensions(Extension)*

    *

    * @return

    * @since 2.6

    */

   public static PropertyList createPropertyList()

   {

      return new PropertyList();

   }

   /**

    * EMPTY, @name(xsd:string)

    *

    * @param name

    * @return

    * @since 2.6

    */

   public static ResetProperty createResetProperty(String name)