/*
    * 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.plugin;
  
  import fr.paris.lutece.portal.business.portlet.PortletType;
  import fr.paris.lutece.portal.business.portlet.PortletTypeHome;
  import fr.paris.lutece.portal.business.right.Right;
  import fr.paris.lutece.portal.business.right.RightHome;
  import fr.paris.lutece.portal.business.style.Theme;
  import fr.paris.lutece.portal.service.content.ContentService;
  import fr.paris.lutece.portal.service.content.ContentServiceEntry;
  import fr.paris.lutece.portal.service.content.XPageAppService;
  import fr.paris.lutece.portal.service.daemon.AppDaemonService;
  import fr.paris.lutece.portal.service.daemon.DaemonEntry;
  import fr.paris.lutece.portal.service.dashboard.DashboardComponentEntry;
  import fr.paris.lutece.portal.service.dashboard.DashboardService;
  import fr.paris.lutece.portal.service.dashboard.admin.AdminDashboardService;
  import fr.paris.lutece.portal.service.database.PluginConnectionService;
  import fr.paris.lutece.portal.service.filter.FilterEntry;
  import fr.paris.lutece.portal.service.filter.FilterService;
  import fr.paris.lutece.portal.service.includes.PageIncludeEntry;
  import fr.paris.lutece.portal.service.includes.PageIncludeService;
  import fr.paris.lutece.portal.service.init.LuteceInitException;
  import fr.paris.lutece.portal.service.insert.InsertService;
  import fr.paris.lutece.portal.service.insert.InsertServiceManager;
  import fr.paris.lutece.portal.service.portal.PortalService;
  import fr.paris.lutece.portal.service.rbac.RBACResourceTypeEntry;
  import fr.paris.lutece.portal.service.rbac.ResourceIdService;
  import fr.paris.lutece.portal.service.search.IndexationService;
  import fr.paris.lutece.portal.service.search.SearchIndexer;
  import fr.paris.lutece.portal.service.search.SearchIndexerEntry;
  import fr.paris.lutece.portal.service.servlet.ServletEntry;
  import fr.paris.lutece.portal.service.servlet.ServletService;
  import fr.paris.lutece.portal.service.sessionlistener.HttpSessionListenerEntry;
  import fr.paris.lutece.portal.service.sessionlistener.HttpSessionListenerService;
  import fr.paris.lutece.portal.service.util.AppPropertiesService;
  import fr.paris.lutece.portal.web.xpages.XPageApplicationEntry;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import javax.servlet.http.HttpServletRequest;
  
  import org.apache.commons.collections.CollectionUtils;
  
  /**
   * This class is the general plugin element
   */
  public abstract class Plugin implements Comparable<Plugin>
  {
      // Constantes
      public static final int PLUGIN_TYPE_FEATURE = 0x01;
      public static final int PLUGIN_TYPE_PORTLET = 0x02;
      public static final int PLUGIN_TYPE_APPLICATION = 0x04;
      public static final int PLUGIN_TYPE_INSERTSERVICE = 0x08;
      public static final int PLUGIN_TYPE_CONTENTSERVICE = 0x10;
      public static final int PLUGIN_TYPE_DAEMON = 0x20;
      private static final String PROPERTY_DEFAULT_ICON_URL = "plugin.image.defaultIconUrl";
      private static final String SCOPE_PORTAL = "portal";
      private static final String SCOPE_XPAGE = "xpage";
  
      // Variables
      private String _strName;
      private String _strVersion;
     private String _strDescription;
     private String _strProvider;
     private String _strProviderUrl;
     private String _strCopyright;
     private String _strPluginClass;
     private String _strDbPoolName;
     private String _strIconUrl;
     private String _strDocumentationUrl;
     private String _strMinCoreVersion;
     private String _strMaxCoreVersion;
     private boolean _bIsInstalled;
     private boolean _bDbPoolRequired;
     private ContentService _contentService;
     private String _strCssStylesheetsScope;
     private String _strJavascriptFilesScope;
 
     // Lists of rights and portlets of the plugin
     private List<XPageApplicationEntry> _listXPageApplications;
     private List<FilterEntry> _listFilters;
     private List<ServletEntry> _listServlets;
     private List<HttpSessionListenerEntry> _listListeners;
     private Map<Integer, List<String>> _listCssStyleSheets;
     private Map<Integer, List<String>> _listJavascriptFiles;
     private List<String> _listAdminCssStyleSheets;
     private List<String> _listAdminJavascriptFiles;
     private List<Right> _listRights;
     private List<PortletType> _listPortletTypes;
     private List<ContentServiceEntry> _listContentServices;
     private List<SearchIndexerEntry> _listSearchIndexers;
     private List<InsertService> _listInsertServices;
     private List<PageIncludeEntry> _listPageIncludes;
     private List<DashboardComponentEntry> _listDashboardComponents;
     private List<DashboardComponentEntry> _listAdminDashboardComponents;
     private List<RBACResourceTypeEntry> _listRBACResourceTypes;
     private List<DaemonEntry> _listDaemons;
     private List<String> _listFreemarkerMacrosFiles;
 
     // hashtable which contains all the params described in the xml plugin file
     private Map<String, String> _mapParams = new HashMap<>( );
     private PluginConnectionService _connectionService;
 
     /**
      * Initializes the plugin at the first load
      *
      */
     public abstract void init( );
 
     /**
      * Load plugin's data from the plugin's xml file.
      *
      * @param pluginFile
      *            The plugin file object
      * @throws LuteceInitException
      *             If an error occured
      */
     void load( PluginFile pluginFile ) throws LuteceInitException
     {
         try
         {
             _strName = pluginFile.getName( );
             _strVersion = pluginFile.getVersion( );
             _strDescription = pluginFile.getDescription( );
             _strProvider = pluginFile.getProvider( );
             _strProviderUrl = pluginFile.getProviderUrl( );
 
             String strDefaultIconUrl = AppPropertiesService.getProperty( PROPERTY_DEFAULT_ICON_URL );
             _strIconUrl = pluginFile.getIconUrl( ).equals( "" ) ? strDefaultIconUrl : pluginFile.getIconUrl( );
             _strDocumentationUrl = pluginFile.getDocumentationUrl( );
             _strCopyright = pluginFile.getCopyright( );
             _strPluginClass = pluginFile.getPluginClass( );
             _strMinCoreVersion = pluginFile.getMinCoreVersion( );
             _strMaxCoreVersion = pluginFile.getMaxCoreVersion( );
             _listXPageApplications = pluginFile.getXPageApplications( );
             _listFilters = pluginFile.getFilters( );
             _listServlets = pluginFile.getServlets( );
             _listListeners = pluginFile.getListeners( );
             _listRights = pluginFile.getRights( );
             _listPortletTypes = pluginFile.getPortletTypes( );
             _listContentServices = pluginFile.getContentServices( );
             _listInsertServices = pluginFile.getInsertServices( );
             _listSearchIndexers = pluginFile.getSearchIndexers( );
             _listPageIncludes = pluginFile.getPageIncludes( );
             _listDashboardComponents = pluginFile.getDashboardComponents( );
             _listAdminDashboardComponents = pluginFile.getAdminDashboardComponents( );
             _listRBACResourceTypes = pluginFile.getRBACResourceTypes( );
             _listDaemons = pluginFile.getDaemons( );
             _mapParams = pluginFile.getParams( );
             _bDbPoolRequired = pluginFile.isDbPoolRequired( );
 
             _listCssStyleSheets = pluginFile.getCssStyleSheetsForAllModes( );
             _strCssStylesheetsScope = ( pluginFile.getCssStylesheetsScope( ) != null ) ? pluginFile.getCssStylesheetsScope( ) : SCOPE_XPAGE;
             _listJavascriptFiles = pluginFile.getJavascriptFilesForAllModes( );
             _strJavascriptFilesScope = ( pluginFile.getJavascriptFilesScope( ) != null ) ? pluginFile.getJavascriptFilesScope( ) : SCOPE_XPAGE;
             _listFreemarkerMacrosFiles = pluginFile.getFreemarkerMacrosFiles( );
             _listAdminCssStyleSheets = pluginFile.getAdminCssStyleSheets( );
             _listAdminJavascriptFiles = pluginFile.getAdminJavascriptFiles( );
             // Register plugin components
             registerXPageApplications( );
             registerFilters( );
             registerServlets( );
             registerListeners( );
             registerContentServices( );
             registerInsertServices( );
             registerSearchIndexers( );
             registerPageIncludes( );
             registerDashboardComponents( );
             registerAdminDashboardComponents( );
             registerRBACResourceTypes( );
             registerDaemons( );
         }
         catch( Exception e )
         {
             throw new LuteceInitException( "Error loading plugin : " + e.getMessage( ), e );
         }
     }
 
     /**
      *
      * @return the content service
      */
     public ContentService getContentService( )
     {
         return _contentService;
     }
 
     /**
      * Returns weither or not plugin has portlet.
      *
      * @return true if the plugin contains one or more portlet
      */
     public boolean hasPortlets( )
     {
         return CollectionUtils.isNotEmpty( _listPortletTypes );
     }
 
     /**
      * Returns weither or not plugin has daemon.
      *
      * @return true if the plugin contains one or more daemon
      */
     public boolean hasDaemons( )
     {
         return CollectionUtils.isNotEmpty( _listDaemons );
     }
 
     /**
      * Returns The daemons list of the plugin.
      *
      * @return The daemons list of the plugin
      */
     public List<DaemonEntry> getDaemons( )
     {
         return _listDaemons;
     }
 
     /**
      * Updates the plg file
      */
     protected void update( )
     {
         PluginService.updatePluginData( this );
     }
 
     /**
      * Modify the plugin status
      *
      * @param bStatus
      *            true installed, false uninstalled
      */
     public void setStatus( boolean bStatus )
     {
         _bIsInstalled = bStatus;
     }
 
     /**
      * Updates a database connection pool associated to the plugin and stores it
      * 
      * @param strPoolName
      *            the name of the pool
      */
     public void updatePoolName( String strPoolName )
     {
         _strDbPoolName = strPoolName;
         _connectionService.setPool( strPoolName );
         update( );
 
         notifyListeners( PluginEvent.PLUGIN_POOL_CHANGED );
     }
 
     /**
      * Updates a database connection pool associated to the plugin and stores it
      * 
      * @param strPoolName
      *            The name of the pool
      */
     public void setPoolName( String strPoolName )
     {
         _strDbPoolName = strPoolName;
     }
 
     /**
      * Gets the current database connection pool associated to the plugin
      * 
      * @return The name of the database for the pool checked
      */
     public String getDbPoolName( )
     {
         return _strDbPoolName;
     }
 
     /**
      * Creates a new right in the rights set
      */
     protected void registerRights( )
     {
         for ( Right right : _listRights )
         {
             RightHome.remove( right.getId( ) );
 
             if ( !( right.getId( ).equals( "" ) ) )
             {
                 RightHome.create( right );
             }
         }
     }
 
     /**
      * Remove a right from the rights set.
      */
     protected void unregisterRights( )
     {
         for ( Right right : _listRights )
         {
             if ( ( right != null ) && ( !( right.getId( ).equals( "" ) ) ) )
             {
                 RightHome.remove( right.getId( ) );
             }
         }
     }
 
     /**
      * Creates a new portlet in the portlets type set
      */
     protected void registerPortlets( )
     {
         for ( PortletType portletType : _listPortletTypes )
         {
             PortletTypeHome.remove( portletType.getId( ) );
 
             if ( ( portletType.getHomeClass( ) != null ) && ( !( portletType.getHomeClass( ).equals( "" ) ) ) )
             {
                 PortletTypeHome.create( portletType );
             }
         }
     }
 
     /**
      * Remove a portlet from the portlets type set.
      */
     protected void unregisterPortlets( )
     {
         for ( PortletType portletType : _listPortletTypes )
         {
             PortletTypeHome.remove( portletType.getId( ) );
         }
     }
 
     /**
      * Register XPage applications
      * 
      * @throws LuteceInitException
      *             If an error occurs
      */
     protected void registerXPageApplications( ) throws LuteceInitException
     {
         for ( XPageApplicationEntry entry : _listXPageApplications )
         {
             entry.setPluginName( getName( ) );
             XPageAppService.registerXPageApplication( entry );
         }
     }
 
     /**
      * Register Filters
      * 
      * @throws LuteceInitException
      *             If an error occurs
      */
     protected void registerFilters( ) throws LuteceInitException
     {
         for ( FilterEntry entry : _listFilters )
         {
             FilterService.getInstance( ).registerFilter( entry, this );
         }
     }
 
     /**
      * Register Servlets
      * 
      * @throws LuteceInitException
      *             If an error occurs
      */
     protected void registerServlets( ) throws LuteceInitException
     {
         for ( ServletEntry entry : _listServlets )
         {
             ServletService.getInstance( ).registerServlet( entry, this );
         }
     }
 
     /**
      * Register listeners
      * 
      * @throws LuteceInitException
      *             if an error occurs
      */
     protected void registerListeners( ) throws LuteceInitException
     {
         for ( HttpSessionListenerEntry entry : _listListeners )
         {
             HttpSessionListenerService.registerListener( entry );
         }
     }
 
     /**
      * Register Content Services
      * 
      * @throws LuteceInitException
      *             If an error occurs
      */
     protected void registerContentServices( ) throws LuteceInitException
     {
         for ( ContentServiceEntry entry : _listContentServices )
         {
             try
             {
                 ContentService./../../../../fr/paris/lutece/portal/service/content/ContentService.html#ContentService">ContentService cs = (ContentService) Class.forName( entry.getClassName( ) ).newInstance( );
 
                 cs.setPluginName( getName( ) );
 
                 PortalService.registerContentService( cs.getName( ), cs );
             }
             catch( InstantiationException | ClassNotFoundException | IllegalAccessException e )
             {
                 throw new LuteceInitException( e.getMessage( ), e );
             }
         }
     }
 
     /**
      * Register Insert Services
      * 
      * @throws LuteceInitException
      *             If an error occurs
      */
     protected void registerInsertServices( ) throws LuteceInitException
     {
         for ( InsertService is : _listInsertServices )
         {
             is.setPluginName( getName( ) );
             InsertServiceManager.registerInsertService( is );
         }
     }
 
     /**
      * Register Search Indexers
      * 
      * @throws LuteceInitException
      *             If an error occurs
      */
     protected void registerSearchIndexers( ) throws LuteceInitException
     {
         for ( SearchIndexerEntry entry : _listSearchIndexers )
         {
             try
             {
                 SearchIndexer/../../../fr/paris/lutece/portal/service/search/SearchIndexer.html#SearchIndexer">SearchIndexer indexer = (SearchIndexer) Class.forName( entry.getClassName( ) ).newInstance( );
                 IndexationService.registerIndexer( indexer );
             }
             catch( IllegalAccessException | ClassNotFoundException | InstantiationException e )
             {
                 throw new LuteceInitException( e.getMessage( ), e );
             }
         }
     }
 
     /**
      * Register Page Includes
      * 
      * @throws LuteceInitException
      *             If an error occured
      */
     protected void registerPageIncludes( ) throws LuteceInitException
     {
         for ( PageIncludeEntry entry : _listPageIncludes )
         {
             entry.setPluginName( getName( ) );
             PageIncludeService.registerPageInclude( entry );
         }
     }
 
     /**
      * Register Dashboard Components
      * 
      * @throws LuteceInitException
      *             If an error occured
      */
     protected void registerDashboardComponents( ) throws LuteceInitException
     {
         for ( DashboardComponentEntry entry : _listDashboardComponents )
         {
             DashboardService.getInstance( ).registerDashboardComponent( entry, this );
         }
     }
 
     /**
      * Register Admin Dashboard Components
      * 
      * @throws LuteceInitException
      *             If an error occured
      */
     protected void registerAdminDashboardComponents( ) throws LuteceInitException
     {
         for ( DashboardComponentEntry entry : _listAdminDashboardComponents )
         {
             AdminDashboardService.getInstance( ).registerDashboardComponent( entry, this );
         }
     }
 
     /**
      * Register RBAC Resource Types
      * 
      * @throws LuteceInitException
      *             If an error occurs
      */
     protected void registerRBACResourceTypes( ) throws LuteceInitException
     {
         for ( RBACResourceTypeEntry entry : _listRBACResourceTypes )
         {
             ResourceIdService ris;
 
             try
             {
                 ris = (ResourceIdService) Class.forName( entry.getClassName( ) ).newInstance( );
                 // Each resource id service should register itself and its permissions
                 ris.register( );
             }
             catch( InstantiationException | ClassNotFoundException | IllegalAccessException e )
             {
                 throw new LuteceInitException( e.getMessage( ), e );
             }
         }
     }
 
     /**
      * Register Daemons
      * 
      * @throws LuteceInitException
      *             If an error occurs
      */
     protected void registerDaemons( ) throws LuteceInitException
     {
         for ( DaemonEntry entry : _listDaemons )
         {
             entry.setPluginName( getName( ) );
             AppDaemonService.registerDaemon( entry );
         }
     }
 
     /**
      * Installs a Plugin
      */
     public void install( )
     {
         // Register a new right for the plugin
         registerRights( );
 
         // Register a new portlets as plugin
         registerPortlets( );
 
         _bIsInstalled = true;
         update( );
 
         notifyListeners( PluginEvent.PLUGIN_INSTALLED );
     }
 
     /**
      * Uninstalls a Plugin
      */
     public void uninstall( )
     {
         // Unregister a new right for the plugin
         unregisterRights( );
 
         // Unregister a new portlets as plugin
         unregisterPortlets( );
         _bIsInstalled = false;
         update( );
 
         notifyListeners( PluginEvent.PLUGIN_UNINSTALLED );
     }
 
     /**
      * Notifiy Listener
      * 
      * @param nEventType
      *            The event type
      */
     private void notifyListeners( int nEventType )
     {
         PluginEventvice/plugin/PluginEvent.html#PluginEvent">PluginEvent event = new PluginEvent( this, nEventType );
         PluginService.notifyListeners( event );
     }
 
     /**
      * Returns the type of the plugin
      *
      * @return the plugin type as a int
      */
     public int getType( )
     {
         // Load the Type
         int nPluginTypeFlags = 0;
 
         if ( CollectionUtils.isNotEmpty( _listXPageApplications ) )
         {
             nPluginTypeFlags |= PLUGIN_TYPE_APPLICATION;
         }
 
         if ( CollectionUtils.isNotEmpty( _listPortletTypes ) )
         {
             nPluginTypeFlags |= PLUGIN_TYPE_PORTLET;
         }
 
         if ( CollectionUtils.isNotEmpty( _listRights ) )
         {
             nPluginTypeFlags |= PLUGIN_TYPE_FEATURE;
         }
 
         if ( CollectionUtils.isNotEmpty( _listInsertServices ) )
         {
             nPluginTypeFlags |= PLUGIN_TYPE_INSERTSERVICE;
         }
 
         if ( CollectionUtils.isNotEmpty( _listContentServices ) )
         {
             nPluginTypeFlags |= PLUGIN_TYPE_CONTENTSERVICE;
         }
 
         if ( CollectionUtils.isNotEmpty( _listDaemons ) )
         {
             nPluginTypeFlags |= PLUGIN_TYPE_DAEMON;
         }
 
         return nPluginTypeFlags;
     }
 
     /**
      * Returns the list of insert services of the plugin
      *
      * @return the plugin list of ContentServiceEntry
      */
     public List<InsertService> getInsertServices( )
     {
         return _listInsertServices;
     }
 
     /**
      * Returns the list of Content services of the plugin
      *
      * @return the plugin list of ContentServiceEntry
      */
     public List<ContentServiceEntry> getContentServices( )
     {
         return _listContentServices;
     }
 
     /**
      * Returns the list of XPage Applications of the plugin
      *
      * @return the plugin list of XPageApplicationEntry
      */
     public List<XPageApplicationEntry> getApplications( )
     {
         return _listXPageApplications;
     }
 
     /**
      * Returns the list of portlet type of the plugin
      *
      * @return the plugin list of portlet type
      */
     public List<PortletType> getPortletTypes( )
     {
         return _listPortletTypes;
     }
 
     /**
      * Sets the list of portlet type
      *
      * @param listPortletTypes
      *            The portlet type list
      */
     public void setPortletTypes( List<PortletType> listPortletTypes )
     {
         _listPortletTypes = listPortletTypes;
     }
 
     /**
      * Returns the list of portlet type of the plugin
      *
      * @return the plugin list of rights
      */
     public List<Right> getRights( )
     {
         return _listRights;
     }
 
     /**
      * Sets plugin rights list
      *
      * @param listRights
      *            The rights list
      */
     public void setRights( List<Right> listRights )
     {
         _listRights = listRights;
     }
 
     /**
      * Returns the name of the plugin
      *
      * @return the plugin name as a String
      */
     public String getName( )
     {
         return _strName;
     }
 
     /**
      * Sets the name of the plugin
      *
      * @param strName
      *            The plugin name
      */
     public void setName( String strName )
     {
         _strName = strName;
     }
 
     /**
      * Returns the version of the plugin
      *
      * @return the plugin version as a String
      */
     public String getVersion( )
     {
         return _strVersion;
     }
 
     /**
      * Sets the version plugin name
      * 
      * @param strVersion
      *            The version
      */
     public void setVersion( String strVersion )
     {
         _strVersion = strVersion;
     }
 
     /**
      * Returns the description of the plugin
      *
      * @return the plugin description as a String
      */
     public String getDescription( )
     {
         return _strDescription;
     }
 
     /**
      * Sets the description of the plugin
      *
      * @param strDescription
      *            The description
      */
     public void setDescription( String strDescription )
     {
         _strDescription = strDescription;
     }
 
     /**
      * Returns the Provider of the plugin
      *
      * @return the plugin Provider as a String
      */
     public String getProvider( )
     {
         return _strProvider;
     }
 
     /**
      * Sets the provider name
      *
      * @param strProvider
      *            The provider name
      */
     public void setProvider( String strProvider )
     {
         _strProvider = strProvider;
     }
 
     /**
      * Returns the Provider's URL of the plugin
      *
      * @return the plugin Provider's URL as a String
      */
     public String getProviderUrl( )
     {
         return _strProviderUrl;
     }
 
     /**
      * Sets the provider url
      *
      * @param strProviderUrl
      *            the name of the provider
      */
     public void setProviderUrl( String strProviderUrl )
     {
         _strProviderUrl = strProviderUrl;
     }
 
     /**
      * Returns the Icon's URL of the plugin
      *
      * @return the plugin Icon's URL as a String
      */
     public String getIconUrl( )
     {
         return _strIconUrl;
     }
 
     /**
      * Sets the url of the plugin's icon
      *
      * @param strIconUrl
      *            The url of icon
      */
     public void setIconUrl( String strIconUrl )
     {
         _strIconUrl = strIconUrl;
     }
 
     /**
      * Returns the Documentation's URL of the plugin
      *
      * @return the plugin Documentation's URL as a String
      */
     public String getDocumentationUrl( )
     {
         return _strDocumentationUrl;
     }
 
     /**
      * Sets the url of the plugin's Documentation
      *
      * @param strDocumentationUrl
      *            The documentation Url
      */
     public void setDocumentationUrl( String strDocumentationUrl )
     {
         _strDocumentationUrl = strDocumentationUrl;
     }
 
     /**
      * Returns the Copyright of the plugin
      *
      * @return the plugin Copyright as a String
      */
     public String getCopyright( )
     {
         return _strCopyright;
     }
 
     /**
      * Sets the copyright
      *
      * @param strCopyright
      *            The copyright
      */
     public void setCopyright( String strCopyright )
     {
         _strCopyright = strCopyright;
     }
 
     /**
      * Returns the main Class of the plugin
      *
      * @return the Class as a String
      */
     public String getServiceClass( )
     {
         return _strPluginClass;
     }
 
     /**
      * Sets the class service of plugin
      *
      * @param strPluginClass
      *            The plugin class
      */
     public void setServiceClass( String strPluginClass )
     {
         _strPluginClass = strPluginClass;
     }
 
     /**
      * Returns the installation status of the plugin
      *
      * @return the installation status as an int
      */
     public boolean isInstalled( )
     {
         return _bIsInstalled;
     }
 
     /**
      * Sets the boolean which shows if the plugin is installed
      *
      * @param bIsInstalled
      *            The installed boolean
      */
     public void setIsInstalled( boolean bIsInstalled )
     {
         _bIsInstalled = bIsInstalled;
     }
 
     /**
      * Returns the min core version compatibility for the plugin
      *
      * @return the min core version as a String
      */
     public String getMinCoreVersion( )
     {
         return _strMinCoreVersion;
     }
 
     /**
      * Sets the the min core version compatibility for the plugin
      *
      * @param strMinCoreVersion
      *            The min core version
      */
     public void setMinCoreVersion( String strMinCoreVersion )
     {
         _strMinCoreVersion = strMinCoreVersion;
     }
 
     /**
      * Returns the max core version compatibility for the plugin
      *
      * @return the max core version as a String
      */
     public String getMaxCoreVersion( )
     {
         return _strMaxCoreVersion;
     }
 
     /**
      * Sets the the max core version compatibility for the plugin
      *
      * @param strMaxCoreVersion
      *            The max core version
      */
     public void setMaxCoreVersion( String strMaxCoreVersion )
     {
         _strMaxCoreVersion = strMaxCoreVersion;
     }
 
     /**
      * Returns if the plugin needs a database connection pool
      *
      * @return <b>true</b> if the plugin needs a database connection pool, otherwise <b>false</b>
      */
     public boolean isDbPoolRequired( )
     {
         return _bDbPoolRequired;
     }
 
     /**
      * Sets the boolean which shows if a pool is required
      *
      * @param bDbPoolRequired
      *            The dbpool boolean
      */
     public void setIsDbPoolRequired( boolean bDbPoolRequired )
     {
         _bDbPoolRequired = bDbPoolRequired;
     }
 
     /**
      * Returns a Connection Service associated to the plugin
      * 
      * @return _connectionService The connection service
      */
     public PluginConnectionService getConnectionService( )
     {
         return _connectionService;
     }
 
     /**
      * Sets the connection service
      *
      * @param connectionService
      *            The connection Service object
      */
     public void setConnectionService( PluginConnectionService connectionService )
     {
         _connectionService = connectionService;
     }
 
     /**
      * Initializes the plugin's ConnectionService
      *
      * @param strPoolName
      *            The pool name
      */
     public void initConnectionService( String strPoolName )
     {
         _connectionService = new PluginConnectionService( strPoolName );
     }
 
     /**
      * Gets plugin's parameters
      * 
      * @return _mapParams The hastable of parameters
      */
     public Map<String, String> getParams( )
     {
         return _mapParams;
     }
 
     /**
      * Gets a parameter value for a given parameter name
      * 
      * @param strParamName
      *            The name of the parameter
      * @return null
      */
     public String getParamValue( String strParamName )
     {
         if ( !_mapParams.containsKey( strParamName ) )
         {
             return null;
         }
 
         return _mapParams.get( strParamName );
     }
 
     /**
      * Sets parameters values with an hashtable
      * 
      * @param mapParams
      *            The parameter map
      */
     public void setParams( Map<String, String> mapParams )
     {
         _mapParams = mapParams;
     }
 
     /**
      * Sets a parameter value for a given parameter name
      * 
      * @param strParamName
      *            The name of the parameter
      * @param strParamValue
      *            The value of the parameter
      */
     public void setParamValue( String strParamName, String strParamValue )
     {
         if ( _mapParams.containsKey( strParamName ) )
         {
             _mapParams.put( strParamName, strParamValue );
         }
     }
 
     /**
      * Implementation of the Comparable interface.
      * 
      * @param plugin
      *            A plugin Object
      * @return 1, 0 ou -1 according the plugin name
      */
     @Override
     public int compareTo( Plugin plugin )
     {
         Comparator<String> comparator = String.CASE_INSENSITIVE_ORDER;
 
         return comparator.compare( getName( ), plugin.getName( ) );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean equals( Object o )
     {
         if ( !( o instanceof Plugin ) )
         {
             return false;
         }
 
         return compareTo( (Plugin) o ) == 0;
     }
 
     /**
      * Returns all CSS Style Sheets of the plugin with no mode associated
      * 
      * @return The list of CSS Style Sheets with no mode associated
      */
     public List<String> getCssStyleSheets( )
     {
         List<String> res = _listCssStyleSheets.get( null );
 
         if ( res == null )
         {
             return Collections.emptyList( );
         }
 
         return res;
     }
 
     /**
      * Returns all CSS Style Sheets of the plugin associated with a mode
      * 
      * @param mode
      *            the mode
      * @return The list of CSS Style Sheets associated with the mode
      * @since 5.1.0
      */
     public List<String> getCssStyleSheets( int mode )
     {
         List<String> res = _listCssStyleSheets.get( mode );
 
         if ( res == null )
         {
             return Collections.emptyList( );
         }
 
         return res;
     }
 
     /**
      * Returns the theme the plugin use for rendering a Xpage
      * 
      * @param request
      *            The HttpServletRequest
      * @return The theme
      */
     public Theme getXPageTheme( HttpServletRequest request )
     {
         return null;
     }
 
     /**
      * Add an Javascript File to the plugin definition, not associated with a mode
      * 
      * @param strJavascriptFile
      *            The Javascript File path
      */
     public void addJavascriptFile( String strJavascriptFile )
     {
         List<String> files = _listJavascriptFiles.computeIfAbsent( null, s -> new ArrayList<>( ) );
         files.add( strJavascriptFile );
     }
 
     /**
      * Returns all Javascript File of the plugin with no mode associated
      * 
      * @return The list of Javascript File with no mode associated
      */
     public List<String> getJavascriptFiles( )
     {
         List<String> res = _listJavascriptFiles.get( null );
 
         if ( res == null )
         {
             return Collections.emptyList( );
         }
 
         return res;
     }
 
     /**
      * Returns all Javascript File of the plugin associated with a mode
      * 
      * @param mode
      *            the mode
      * @return The list of Javascript File with associated with the mode
      * @since 5.1.0
      */
     public List<String> getJavascriptFiles( int mode )
     {
         List<String> res = _listJavascriptFiles.get( mode );
 
         if ( res == null )
         {
             return Collections.emptyList( );
         }
 
         return res;
     }
 
     /**
      * Give the scope of css stylesheets
      * 
      * @return true if scope is portal otherwise false
      */
     public boolean isCssStylesheetsScopePortal( )
     {
         return ( ( _strCssStylesheetsScope != null ) && _strCssStylesheetsScope.equalsIgnoreCase( SCOPE_PORTAL ) );
     }
 
     /**
      * Give the scope of css stylesheets
      * 
      * @return true if scope is portal otherwise false
      */
     public boolean isCssStylesheetsScopeXPage( )
     {
         return ( ( _strCssStylesheetsScope != null ) && _strCssStylesheetsScope.equalsIgnoreCase( SCOPE_XPAGE ) );
     }
 
     /**
      * Give the scope of javascripts
      * 
      * @return true if scope is portal otherwise false
      */
     public boolean isJavascriptFilesScopePortal( )
     {
         return ( ( _strJavascriptFilesScope != null ) && _strJavascriptFilesScope.equalsIgnoreCase( SCOPE_PORTAL ) );
     }
 
     /**
      * Give the scope of javascripts
      * 
      * @return true if scope is portal otherwise false
      */
     public boolean isJavascriptFilesScopeXPage( )
     {
         return ( ( _strJavascriptFilesScope != null ) && _strJavascriptFilesScope.equalsIgnoreCase( SCOPE_XPAGE ) );
     }
 
     /**
      * Return the list of stylesheets that should be used in the Back Office
      * 
      * @return the list of stylesheets that should be used in the Back Office
      * @since 5.1
      */
     public List<String> getAdminCssStyleSheets( )
     {
         return _listAdminCssStyleSheets;
     }
 
     /**
      * Return the list of Javascript Files that should be used in the Back Office
      * 
      * @return the list of Javascript Files that should be used in the Back Office
      * @since 5.1
      */
     public List<String> getAdminJavascriptFiles( )
     {
         return _listAdminJavascriptFiles;
     }
 
     /**
      * Adds a that file that will be autoincluded in freemarker templates
      * 
      * @param strMacroFileName
      *            the file name
      */
     public void addFreemarkerMacrosFile( String strMacroFileName )
     {
         _listFreemarkerMacrosFiles.add( strMacroFileName );
     }
 
     /**
      * Gets the free marker macros files.
      *
      * @return the free marker macros files
      */
     public List<String> getFreeMarkerMacrosFiles( )
     {
         return _listFreemarkerMacrosFiles;
     }
 
     /**
      * Useful for debugging
      *
      * @return The plugin object in String format
      */
     @Override
     public String toString( )
     {
         return getName( );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public int hashCode( )
     {
         if ( getName( ) == null )
         {
             return 0;
         }
 
         return getName( ).toLowerCase( ).hashCode( );
     }
 }