/*
    * Copyright (c) 2002-2022, City of Paris
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    *
    *  1. Redistributions of source code must retain the above copyright notice
   *     and the following disclaimer.
   *
   *  2. Redistributions in binary form must reproduce the above copyright notice
   *     and the following disclaimer in the documentation and/or other materials
   *     provided with the distribution.
   *
   *  3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
   *     contributors may be used to endorse or promote products derived from
   *     this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   *
   * License 1.0
   */
  package fr.paris.lutece.portal.service.portal;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Properties;
  
  import javax.servlet.http.HttpServletRequest;
  
  import org.apache.commons.lang3.StringUtils;
  
  import fr.paris.lutece.portal.business.XmlContent;
  import fr.paris.lutece.portal.business.page.Page;
  import fr.paris.lutece.portal.business.page.PageHome;
  import fr.paris.lutece.portal.business.portalcomponent.PortalComponentHome;
  import fr.paris.lutece.portal.business.portlet.Portlet;
  import fr.paris.lutece.portal.business.portlet.PortletHome;
  import fr.paris.lutece.portal.business.style.ModeHome;
  import fr.paris.lutece.portal.business.stylesheet.StyleSheet;
  import fr.paris.lutece.portal.service.cache.IPathCacheService;
  import fr.paris.lutece.portal.service.content.ContentService;
  import fr.paris.lutece.portal.service.content.PageData;
  import fr.paris.lutece.portal.service.datastore.DatastoreService;
  import fr.paris.lutece.portal.service.html.XmlTransformerService;
  import fr.paris.lutece.portal.service.includes.PageInclude;
  import fr.paris.lutece.portal.service.includes.PageIncludeService;
  import fr.paris.lutece.portal.service.message.SiteMessageException;
  import fr.paris.lutece.portal.service.page.IPageService;
  import fr.paris.lutece.portal.service.plugin.PluginService;
  import fr.paris.lutece.portal.service.security.LuteceUser;
  import fr.paris.lutece.portal.service.security.SecurityService;
  import fr.paris.lutece.portal.service.spring.SpringContextService;
  import fr.paris.lutece.portal.service.template.AppTemplateService;
  import fr.paris.lutece.portal.service.util.AppPathService;
  import fr.paris.lutece.portal.service.util.AppPropertiesService;
  import fr.paris.lutece.portal.web.constants.Markers;
  import fr.paris.lutece.portal.web.constants.Parameters;
  import fr.paris.lutece.portal.web.l10n.LocaleService;
  import fr.paris.lutece.util.date.DateUtil;
  import fr.paris.lutece.util.html.HtmlTemplate;
  import fr.paris.lutece.util.xml.XmlUtil;
  
  /**
   * This class provides methods to build the pages of the portal and manage the cache
   */
  public final class PortalService
  {
      // //////////////////////////////////////////////////////////////////////////
      // Constants
      private static final int PORTAL_COMPONENT_PAGE_PATH_ID = 5;
  
      // Properties
      private static final String PROPERTY_HOME_PAGE_HEADER = "home.page.header.mode";
      private static final String PROPERTY_INTERNAL_PAGE_HEADER = "internal.page.header.mode";
      private static final String PROPERTY_PAGE_TOOLS_MENU = "page.tools.menu.mode";
      private static final String PROPERTY_PORTAL_FOOTER = "page.portal.footer.mode";
      private static final String PROPERTY_PATH_ON_ROOT = "lutece.root.path";
      private static final String PROPERTY_ENCODING = "lutece.encoding";
      private static final String PROPERTY_ENCODING_DEFAULT = "UTF-8";
  
      // Datastore keys
      private static final String KEY_SITE_NAME = "portal.site.site_property.name";
      private static final String KEY_WEBMASTER_EMAIL = "portal.site.site_property.email";
 
     // Templates
     private static final String TEMPLATE_PAGE_FRAMESET = "skin/site/page_frameset.html";
     private static final String TEMPLATE_HOME_PAGE_HEADER = "skin/site/page_header_home.html";
     private static final String TEMPLATE_INTERNAL_PAGE_HEADER = "skin/site/page_header_internal.html";
     private static final String TEMPLATE_PAGE_TOOLS_MENU = "skin/site/page_menu_tools.html";
     private static final String TEMPLATE_PAGE_PATH = "skin/site/page_path.html";
     private static final String TEMPLATE_PORTAL_FOOTER = "skin/site/portal_footer.html";
     private static final String TEMPLATE_ADMIN_CSS_LINKS = "admin/stylesheet_link.html";
 
     // Markers
     private static final String MARKER_TARGET = "target";
     private static final String MARKER_PAGE_DATA = "data";
     private static final String PLUGIN_EXTEND_NAME = "extend";
     private static final String PLUGIN_CONTACT_NAME = "contact";
     private static final String MARK_IS_EXTEND_INSTALLED = "isExtendInstalled";
     private static final String MARK_IS_CONTACT_INSTALLED = "isContactInstalled";
     private static final String MARK_LUTECE_USER = "lutece_user";
     private static final String TARGET_TOP = "target='_top'";
     private static final String BOOKMARK_BASE_URL = "@base_url@";
     private static final String MARK_LAST_MODIFIED = "last_modified";
     private static final String MARK_DISPLAY_LAST_MODIFIED = "display_last_modified";
 
     // Added in v1.3
     private static final int MODE_NORMAL = 0;
     private static final int MODE_ADMIN = 1;
     private static final String PARAMETER_SITE_PATH = "site-path";
 
     // Content Service registry
     private static Map<String, ContentService> _mapContentServicesRegistry = new HashMap<>( );
     private static IPageService _pageService = SpringContextService.getBean( "pageService" );
 
     /**
      * Private Constructor
      */
     private PortalService( )
     {
     }
 
     /**
      * Analyzes request's parameters to find the ContentService that should handle the request
      *
      * @param request
      *            The HTTP request
      * @return ContentService that should handle the request
      */
     public static ContentService getInvokedContentService( HttpServletRequest request )
     {
         for ( ContentService cs : getContentServicesList( ) )
         {
             if ( cs.isInvoked( request ) )
             {
                 return cs;
             }
         }
 
         return null;
     }
 
     /**
      * Registers a new ContentService
      * 
      * @param strName
      *            The name
      * @param cs
      *            The ContentService
      */
     public static void registerContentService( String strName, ContentService cs )
     {
         _mapContentServicesRegistry.put( strName, cs );
     }
 
     /**
      * Returns all registered Content services
      *
      * @return A collection containing all registered Content services
      */
     public static Collection<ContentService> getContentServicesList( )
     {
         return _mapContentServicesRegistry.values( );
     }
 
     /**
      * Returns the identifier of the root page of the portal read in the lutece.properties file
      *
      * @return The identifier of the root page
      */
     public static int getRootPageId( )
     {
         return AppPropertiesService.getPropertyInt( "lutece.page.root", 1 );
     }
 
     /**
      * Return the default page of the portal (the home page)
      * 
      * @param request
      *            The request
      * @param nMode
      *            the mode id
      * @return default page as a String
      * @throws SiteMessageException
      *             occurs when a site message need to be displayed
      */
     public static String getDefaultPage( HttpServletRequest request, int nMode ) throws SiteMessageException
     {
         return _pageService.getPage( String.valueOf( getRootPageId( ) ), nMode, request );
     }
 
     /**
      * Return the xml content of the pages contained in the list specified in parameter
      *
      * @param listPages
      *            The pages list
      * @return the xml code for the content page
      */
     public static String getXmlPagesList( Collection<Page> listPages )
     {
         StringBuffer strXml = new StringBuffer( );
         strXml.append( XmlUtil.getXmlHeader( ) );
         XmlUtil.beginElement( strXml, XmlContent.TAG_CHILD_PAGES_LIST );
 
         for ( Page page : listPages )
         {
             XmlUtil.beginElement( strXml, XmlContent.TAG_PAGE );
             XmlUtil.addElement( strXml, XmlContent.TAG_PAGE_ID, page.getId( ) );
             XmlUtil.addElementHtml( strXml, XmlContent.TAG_PAGE_NAME, page.getName( ) );
             XmlUtil.endElement( strXml, XmlContent.TAG_PAGE );
         }
 
         XmlUtil.endElement( strXml, XmlContent.TAG_CHILD_PAGES_LIST );
 
         return strXml.toString( );
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // pages builder
 
     /**
      * Returns the html code which represents the page content
      * 
      * @param data
      *            The structure which contains the informations about the page
      * @param nMode
      *            The mode in which displaying the page : normal or administration
      * @param request
      *            The request
      * @return The html code of a page
      */
     public static String buildPageContent( PageData data, int nMode, HttpServletRequest request )
     {
         return buildPageContent( getRootPageId( ), data, nMode, request );
     }
 
     /**
      * Returns the html code which represents the page content
      * 
      * @param nCurrentPageId
      *            the current page id
      * @param data
      *            The structure which contains the informations about the page
      * @param nMode
      *            The mode in which displaying the page : normal or administration
      * @param request
      *            The request
      * @return The html code of a page
      */
     public static String buildPageContent( int nCurrentPageId, PageData data, int nMode, HttpServletRequest request )
     {
         Locale locale = null;
         HashMap<String, Object> model = new HashMap<>( );
         LuteceUser user = null;
         String strWebmasterEmail = DatastoreService.getDataValue( KEY_WEBMASTER_EMAIL, "" );
         model.put( Markers.WEBMASTER_EMAIL, strWebmasterEmail );
 
         locale = LocaleService.getContextUserLocale( request );
 
         if ( request != null )
         {
             user = SecurityService.getInstance( ).getRegisteredUser( request );
             if ( nMode != MODE_ADMIN )
             {
                 model.put( MARK_LUTECE_USER, user );
             }
         }
 
         List<PageInclude> listIncludes = PageIncludeService.getIncludes( );
 
         for ( PageInclude pic : listIncludes )
         {
             pic.fillTemplate( model, data, nMode, request );
         }
 
         String strHeader = data.isHomePage( ) ? AppPropertiesService.getProperty( PROPERTY_HOME_PAGE_HEADER + nMode, TEMPLATE_HOME_PAGE_HEADER )
                 : AppPropertiesService.getProperty( PROPERTY_INTERNAL_PAGE_HEADER + nMode, TEMPLATE_INTERNAL_PAGE_HEADER );
         HtmlTemplate tHeader = AppTemplateService.getTemplate( strHeader, locale, model );
 
         String strFooter = AppPropertiesService.getProperty( PROPERTY_PORTAL_FOOTER + nMode, TEMPLATE_PORTAL_FOOTER );
         String strToolsMenu = AppPropertiesService.getProperty( PROPERTY_PAGE_TOOLS_MENU + nMode, TEMPLATE_PAGE_TOOLS_MENU );
         model.put( MARK_IS_CONTACT_INSTALLED, isContactActivated( ) );
 
         boolean bDisplayLastModified = data.getDisplayDateUpdate( );
         model.put( MARK_DISPLAY_LAST_MODIFIED, bDisplayLastModified );
 
         if ( request != null )
         {
             String strLastModified = DateUtil.getDateString( data.getDateUpdate( ), locale );
             model.put( MARK_LAST_MODIFIED, strLastModified );
         }
         HtmlTemplate tFooter = AppTemplateService.getTemplate( strFooter, locale, model );
 
         HtmlTemplate tToolsMenu = AppTemplateService.getTemplate( strToolsMenu, locale, model );
         model.put( Markers.PAGE_HEADER, tHeader.getHtml( ) );
         model.put( MARKER_PAGE_DATA, data );
         model.put( Markers.PAGE_NAME, data.getName( ) == null ? "" : data.getName( ) );
         model.put( Markers.PAGE_CONTENT, data.getContent( ) == null ? "" : data.getContent( ) );
         model.put( Markers.PAGE_PATH, data.getPagePath( ) == null ? "" : data.getPagePath( ) );
         model.put( Markers.PAGE_TOOLS_MENU, tToolsMenu.getHtml( ) );
         model.put( Markers.PAGE_ID, nCurrentPageId );
 
         model.put( Markers.PAGE_FOOTER, tFooter.getHtml( ) );
 
         String strBaseUrl = request != null ? AppPathService.getBaseUrl( request ) : ""; // request could be null
                                                                                          // (method called by daemons
                                                                                          // or batch)
 
         // for link service
         model.put( Markers.WEBAPP_PATH_FOR_LINKSERVICE, strBaseUrl );
         model.put( Markers.BASE_URL, strBaseUrl );
 
         String strEncoding = AppPropertiesService.getProperty( PROPERTY_ENCODING, PROPERTY_ENCODING_DEFAULT );
 
         if ( strEncoding == null || strEncoding.equals( "" ) )
         {
             strEncoding = PROPERTY_ENCODING_DEFAULT;
         }
 
         model.put( Markers.ENCODING, strEncoding );
 
         model.put( Markers.USER_CONTEXT_LANGUAGE, locale );
 
         model.put( MARK_IS_EXTEND_INSTALLED, isExtendActivated( ) );
 
         HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_PAGE_FRAMESET, locale, model );
 
         template.substitute( BOOKMARK_BASE_URL, request != null ? AppPathService.getBaseUrl( request ) : "" ); // request
                                                                                                                // could
                                                                                                                // be
                                                                                                                // null
                                                                                                                // (method
                                                                                                                // called
                                                                                                                // by
                                                                                                                // daemons
                                                                                                                // or
                                                                                                                // batch)
 
         return template.getHtml( );
     }
 
     // //////////////////////////////////////////////////////////////////////////
     // Management of the pages path
 
     /**
      * Returns the formated path of the site page whose identifier is specified in parameter
      *
      * @param nPageId
      *            The identifier of the page
      * @param nMode
      *            The mode to use for the formatting
      * @param request
      *            The HTTP request
      * @return the formated path
      */
     public static String getPagePathContent( int nPageId, int nMode, HttpServletRequest request )
     {
         String strPathOnRoot = AppPropertiesService.getProperty( PROPERTY_PATH_ON_ROOT );
 
         // If the current page is the home page or the string strPathOnRoot equals
         // false, not display the path
         if ( nPageId == getRootPageId( ) && ( strPathOnRoot == null || strPathOnRoot.equalsIgnoreCase( "false" ) ) )
         {
             return "";
         }
 
         // Selection of the XSL stylesheet
         // Added in v1.3
         // Use the same stylesheet for normal or admin mode
         StyleSheet xslSource;
 
         switch( nMode )
         {
             case MODE_NORMAL:
             case MODE_ADMIN:
                 xslSource = PortalComponentHome.getXsl( PORTAL_COMPONENT_PAGE_PATH_ID, MODE_NORMAL );
 
                 break;
 
             default:
                 xslSource = PortalComponentHome.getXsl( PORTAL_COMPONENT_PAGE_PATH_ID, nMode );
 
                 break;
         }
 
         String strXml = getXmlPagesList( getPagePath( nPageId ) );
 
         Properties outputProperties = ModeHome.getOuputXslProperties( nMode );
 
         // Added in v1.3
         // Add a path param for choose url to use in admin or normal mode
         Map<String, String> mapParamRequest = new HashMap<>( );
         setXslPortalPath( mapParamRequest, nMode );
 
         XmlTransformerServicervice.html#XmlTransformerService">XmlTransformerService xmlTransformerService = new XmlTransformerService( );
         String strPath = xmlTransformerService.transformBySourceWithXslCache( strXml, xslSource, mapParamRequest, outputProperties );
 
         return formatPath( strPath, nMode, request );
     }
 
     /**
      * Returns the formated path of a xpage (ex : result of a seek)
      *
      * @param strXPageName
      *            The xpage name
      * @param nMode
      *            The mode to use for the formatting
      * @param request
      *            The HTTP request
      * @return the formated path
      */
     public static String getXPagePathContent( String strXPageName, int nMode, HttpServletRequest request )
     {
         final IPathCacheService pathCacheService = SpringContextService.getBean( IPathCacheService.BEAN_NAME );
 
         final String strKey = pathCacheService.getKey( strXPageName, nMode, request );
 
         String strRes = pathCacheService.getFromCache( strKey );
 
         if ( strRes != null )
         {
             return strRes;
         }
 
         // Added in v1.3
         StyleSheet xslSource;
 
         // Selection of the XSL stylesheet
         switch( nMode )
         {
             case MODE_NORMAL:
             case MODE_ADMIN:
                 xslSource = PortalComponentHome.getXsl( PORTAL_COMPONENT_PAGE_PATH_ID, MODE_NORMAL );
 
                 break;
 
             default:
                 xslSource = PortalComponentHome.getXsl( PORTAL_COMPONENT_PAGE_PATH_ID, nMode );
 
                 break;
         }
 
         String strXml = StringUtils.EMPTY;
         String strPageId = request.getParameter( Parameters.PAGE_ID );
 
         if ( StringUtils.isNotBlank( strPageId ) && StringUtils.isNumeric( strPageId ) )
         {
             int nPageId = Integer.parseInt( strPageId );
             strXml = getXmlPagesList( getXPagePath( strXPageName, nPageId ) );
         }
         else
         {
             String strPortletId = request.getParameter( Parameters.PORTLET_ID );
 
             if ( StringUtils.isNotBlank( strPortletId ) && StringUtils.isNumeric( strPortletId ) )
             {
                 int nPortletId = Integer.parseInt( strPortletId );
                 Portlet portlet = PortletHome.findByPrimaryKey( nPortletId );
 
                 if ( portlet != null )
                 {
                     int nPageId = portlet.getPageId( );
                     strXml = getXmlPagesList( getXPagePath( strXPageName, nPageId ) );
                 }
             }
         }
 
         if ( StringUtils.isBlank( strXml ) )
         {
             strXml = getXmlPagesList( getXPagePath( strXPageName ) );
         }
 
         Properties outputProperties = ModeHome.getOuputXslProperties( nMode );
 
         // Added in v1.3
         // Add a path param for choose url to use in admin or normal mode
         Map<String, String> mapXslParams = new HashMap<>( );
         setXslPortalPath( mapXslParams, nMode );
 
         XmlTransformerServicervice.html#XmlTransformerService">XmlTransformerService xmlTransformerService = new XmlTransformerService( );
         String strPath = xmlTransformerService.transformBySourceWithXslCache( strXml, xslSource, mapXslParams, outputProperties );
 
         strRes = formatPath( strPath, nMode, request );
 
         pathCacheService.putInCache( strKey, strRes );
 
         return strRes;
     }
 
     /**
      * Builds a collection of pages corresponding to the path of the page specified in parameter
      *
      * @param nPageId
      *            The identifier of the page
      * @return A collection of pages from the home page to the specified page
      */
     public static Collection<Page> getPagePath( int nPageId )
     {
         ArrayList<Page> list = new ArrayList<>( );
         Page page = PageHome.getPage( nPageId );
         int nParentPageId = page.getParentPageId( );
         list.add( page );
 
         while ( nParentPageId != 0 )
         {
             Page parentPage = PageHome.getPage( nParentPageId );
 
             // Insert the page in the begin of the list
             list.add( 0, parentPage );
             nParentPageId = parentPage.getParentPageId( );
         }
 
         return list;
     }
 
     /**
      * Builds a collection of pages corresponding to the path of a xpage
      *
      * @param strXPageName
      *            The xpage name
      * @return A collection of pages made by the home page and the xpage
      */
     private static Collection<Page> getXPagePath( String strXPageName )
     {
         ArrayList<Page> list = new ArrayList<>( );
         Page homePage = PageHome.getPage( getRootPageId( ) );
         list.add( homePage );
 
         Pagetal/business/page/Page.html#Page">Page xPage = new Page( );
         xPage.setName( strXPageName );
         list.add( xPage );
 
         return list;
     }
 
     /**
      * Builds a collection of pages corresponding to the path of a xpage
      *
      * @param strXPageName
      *            The xpage name
      * @param nPageId
      *            The Page's ID
      * @return A collection of pages made by the home page and the xpage
      */
     private static Collection<Page> getXPagePath( String strXPageName, int nPageId )
     {
         List<Page> list = new ArrayList<>( );
         Page page = PageHome.getPage( nPageId );
 
         if ( page != null )
         {
             int nParentPageId = page.getParentPageId( );
 
             while ( ( nParentPageId > 0 ) && ( nParentPageId != getRootPageId( ) ) )
             {
                 Page parentPage = PageHome.getPage( nParentPageId );
 
                 if ( parentPage != null )
                 {
                     // Insert the page at the beginning of the list
                     list.add( 0, parentPage );
                     nParentPageId = parentPage.getParentPageId( );
                 }
             }
 
             if ( nPageId != getRootPageId( ) )
             {
                 list.add( page );
             }
         }
 
         // Insert the home page at the beginning of the list
         Page homePage = PageHome.getPage( getRootPageId( ) );
         list.add( 0, homePage );
 
         // Insert the XPage at the end of the list
         Pagetal/business/page/Page.html#Page">Page xPage = new Page( );
         xPage.setName( strXPageName );
         xPage.setId( nPageId );
         list.add( xPage );
 
         return list;
     }
 
     // //////////////////////////////////////////////////////////////////////////
 
     /**
      * Formats the path specified in parameter and returns it
      *
      * @param strPath
      *            The path to format
      * @param nMode
      *            The mode to use for the formatting
      * @param request
      *            The HTTP request
      * @return the html code to display the path
      */
     public static String formatPath( String strPath, int nMode, HttpServletRequest request )
     {
         HashMap<String, Object> model = new HashMap<>( );
         model.put( Markers.PAGE_PATH, strPath );
 
         List<PageInclude> listIncludes = PageIncludeService.getIncludes( );
         PageData/service/content/PageData.html#PageData">PageData data = new PageData( );
 
         for ( PageInclude pic : listIncludes )
         {
             pic.fillTemplate( model, data, nMode, request );
         }
 
         HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_PAGE_PATH, ( request == null ) ? null : request.getLocale( ), model );
 
         return template.getHtml( );
     }
 
     /**
      * Return the xml content of the pages specified by the xml code. This is called when using the Extended Xml path Label.
      *
      * @param strXmlExtend
      *            The xml code to append to the path
      * @return the xml code for the content page
      */
     private static String getXmlPagesListExtended( String strXmlExtend )
     {
         StringBuffer strXml = new StringBuffer( );
         strXml.append( XmlUtil.getXmlHeader( ) );
         XmlUtil.beginElement( strXml, XmlContent.TAG_CHILD_PAGES_LIST );
 
         Page homePage = PageHome.getPage( getRootPageId( ) );
 
         XmlUtil.beginElement( strXml, XmlContent.TAG_PAGE );
         XmlUtil.addElement( strXml, XmlContent.TAG_PAGE_ID, homePage.getId( ) );
         XmlUtil.addElementHtml( strXml, XmlContent.TAG_PAGE_NAME, homePage.getName( ) );
         XmlUtil.endElement( strXml, XmlContent.TAG_PAGE );
 
         strXml.append( strXmlExtend );
 
         XmlUtil.endElement( strXml, XmlContent.TAG_CHILD_PAGES_LIST );
 
         return strXml.toString( );
     }
 
     /**
      * Returns the formated extended path of an xpage. This method is used when giving the list of elements in the path as a Xml code. This is called when using
      * the Extended Xml path Label.
      *
      * @param strXPageName
      *            The xpage name
      * @param nMode
      *            The mode to use for the formatting
      * @param strTitlesUrls
      *            list of links (url and titles)
      * @param request
      *            The HTTP request
      * @return the formatted path
      */
     public static String getXPagePathContent( String strXPageName, int nMode, String strTitlesUrls, HttpServletRequest request )
     {
         final IPathCacheService pathCacheService = SpringContextService.getBean( IPathCacheService.BEAN_NAME );
 
         final String strKey = pathCacheService.getKey( strXPageName, nMode, strTitlesUrls, request );
 
         String strRes = pathCacheService.getFromCache( strKey );
 
         if ( strRes != null )
         {
             return strRes;
         }
 
         // Selection of the XSL stylesheet
         StyleSheet xslSource;
 
         // Selection of the XSL stylesheet
         switch( nMode )
         {
             case MODE_NORMAL:
             case MODE_ADMIN:
                 xslSource = PortalComponentHome.getXsl( PORTAL_COMPONENT_PAGE_PATH_ID, MODE_NORMAL );
 
                 break;
 
             default:
                 xslSource = PortalComponentHome.getXsl( PORTAL_COMPONENT_PAGE_PATH_ID, nMode );
 
                 break;
         }
 
         String strXml = getXmlPagesListExtended( strTitlesUrls );
 
         Properties outputProperties = ModeHome.getOuputXslProperties( nMode );
 
         // Added in v1.3
         // Add a path param for choose url to use in admin or normal mode
         Map<String, String> mapXslParams = new HashMap<>( );
         setXslPortalPath( mapXslParams, nMode );
 
         XmlTransformerServicervice.html#XmlTransformerService">XmlTransformerService xmlTransformerService = new XmlTransformerService( );
         String strPath = xmlTransformerService.transformBySourceWithXslCache( strXml, xslSource, mapXslParams, outputProperties );
 
         strRes = formatPath( strPath, nMode, request );
 
         pathCacheService.putInCache( strKey, strRes );
 
         return strRes;
     }
 
     /**
      * Sets XSL portal path
      * 
      * @param mapParameters
      *            Parameters as a map
      * @param nMode
      *            The mode
      */
     public static void setXslPortalPath( Map<String, String> mapParameters, int nMode )
     {
         if ( nMode != MODE_ADMIN )
         {
             mapParameters.put( PARAMETER_SITE_PATH, AppPathService.getPortalUrl( ) );
         }
         else
         {
             mapParameters.put( PARAMETER_SITE_PATH, AppPathService.getAdminPortalUrl( ) );
             mapParameters.put( MARKER_TARGET, TARGET_TOP );
         }
     }
 
     /**
      * Returns the site name
      * 
      * @return The site name
      */
     public static String getSiteName( )
     {
         return DatastoreService.getDataValue( KEY_SITE_NAME, StringUtils.EMPTY );
     }
 
     /**
      * Check if the extend plugin is activated
      * 
      * @return True if the plugin is activated, false otherwise
      */
     public static boolean isExtendActivated( )
     {
         return PluginService.isPluginEnable( PLUGIN_EXTEND_NAME );
     }
 
     /**
      * Check if the cotnact plugin is activated
      * 
      * @return True if the plugin is activated, false otherwise
      */
     public static boolean isContactActivated( )
     {
         return PluginService.isPluginEnable( PLUGIN_CONTACT_NAME );
     }
 
     /**
      * Get the list of CSS links for session less pages
      * 
      * @return The HTML code providing the list of CSS links.
      */
     public static String getAdminCssLinks( )
     {
         HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_ADMIN_CSS_LINKS );
         return template.getHtml( );
     }
 }