luos/workflow/engine/classes/PMPluginRegistry.php

<?php
use ProcessMaker\Plugins\PluginRegistry;

class PMPluginRegistry
{
    private $_aPluginDetails = array ();
    private $_aPlugins = array ();
    private $_aMenus = array ();
    private $_aFolders = array ();
    private $_aTriggers = array ();
    private $_aDashlets = array ();
    private $_aReports = array ();
    private $_aPmFunctions = array ();
    private $_aRedirectLogin = array ();
    private $_aSteps = array ();
    private $_aCSSStyleSheets = array ();
    private $_aToolbarFiles = array ();
    private $_aCaseSchedulerPlugin = array ();
    private $_aTaskExtendedProperties = array ();
    private $_aDashboardPages = array ();
    private $_aCronFiles = array ();
    private $_arrayDesignerMenu = array();
    private $_aMenuOptionsToReplace = array ();
    private $_aImportProcessCallbackFile = array ();
    private $_aOpenReassignCallback = array ();
    private $_arrayDesignerSourcePath = array();

    /**
     * Registry a plugin javascript to include with js core at same runtime
     */
    private $_aJavascripts = array ();

    /**
     * Contains all rest services classes from plugins
     */
    private $_restServices = array ();

    private $_restExtendServices = array ();

    private $_restServiceEnabled = array();

    private static $instance = null;
    private static $stateSaved = null;

    /**
     * This function is the constructor of the PMPluginRegistry class
     * param
     *
     * @return void
     */
    public function __construct ()
    {
    }

    /**
     * This function is instancing to this class
     * param
     *
     * @return object
     */
    public static function getSingleton()
    {
        return PluginRegistry::loadSingleton();
    }

    /**
     * Load the singleton instance from a serialized stored file
     *
     * @param $file
     * @return object
     * @throws Exception
     */
    public static function loadSingleton($file)
    {
        return PluginRegistry::loadSingleton();
    }

    /**
     * This function generates a storable representation of a value
     * param
     *
     * @return void
     */
    public function serializeInstance ()
    {
        return serialize( $this );
    }

    /**
     * This function takes a single serialized variable and converts it back a code
     *
     * @param string $serialized
     * @return void
     */
    public function unSerializeInstance ($serialized)
    {
        if (self::$instance == null) {
            self::$instance = new PMPluginRegistry();
        }

        $instance = unserialize( $serialized );
        self::$instance = $instance;
    }

    /**
     * Save the current instance to the plugin singleton
     */
    public function save ()
    {
        file_put_contents( PATH_DATA_SITE . 'plugin.singleton', $this->serializeInstance() );
    }

    /**
     * Register the plugin in the singleton
     *
     * @param unknown_type $sClassName
     * @param unknown_type $sNamespace
     * @param unknown_type $sFilename
     */
    public function registerPlugin ($sNamespace, $sFilename = null)
    {
        $sClassName = $sNamespace . "plugin";
        $plugin = new $sClassName( $sNamespace, $sFilename );

        if (isset( $this->_aPluginDetails[$sNamespace] )) {
            $this->_aPluginDetails[$sNamespace]->iVersion = $plugin->iVersion;

            return;
        }

        $detail = new PluginDetail( $sNamespace, $sClassName, $sFilename, $plugin->sFriendlyName, $plugin->sPluginFolder, $plugin->sDescription, $plugin->sSetupPage, $plugin->iVersion );

        if (isset( $plugin->aWorkspaces )) {
            $detail->aWorkspaces = $plugin->aWorkspaces;
        }

        if (isset( $plugin->bPrivate )) {
            $detail->bPrivate = $plugin->bPrivate;
        }

        //if (isset($this->_aPluginDetails[$sNamespace])){
        //    $detail->enabled = $this->_aPluginDetails[$sNamespace]->enabled;
        //}


        $this->_aPluginDetails[$sNamespace] = $detail;
    }

    /**
     * get the plugin details, by filename
     *
     * @param unknown_type $sFilename
     */
    public function getPluginDetails ($sFilename)
    {
        foreach ($this->_aPluginDetails as $key => $row) {
            if ($sFilename == baseName( $row->sFilename )) {
                return $row;
            }
        }
        return null;
    }

    /**
     * Enable the plugin in the singleton
     *
     * @param unknown_type $sNamespace
     */
    public function enablePlugin ($sNamespace)
    {
        foreach ($this->_aPluginDetails as $namespace => $detail) {
            if ($sNamespace == $namespace) {
                $this->registerFolder( $sNamespace, $sNamespace, $detail->sPluginFolder );
                //register the default directory, later we can have more
                $this->_aPluginDetails[$sNamespace]->enabled = true;
                if (class_exists($detail->sClassName)) {
                    $oPlugin = new $detail->sClassName( $detail->sNamespace, $detail->sFilename );
                } else {
                    $oPlugin = $detail;
                }
                $this->_aPlugins[$detail->sNamespace] = $oPlugin;
                if (method_exists( $oPlugin, 'enable' )) {
                    $oPlugin->enable();
                }

                /*
                 * 1. register <plugin-dir>/src directory for autoloading
                 * 2. verify if rest service is enabled
                 * 3. register rest service directory
                 */
                $pluginSrcDir = PATH_PLUGINS . $detail->sNamespace . PATH_SEP . 'src';

                if (is_dir($pluginSrcDir)) {
                    $loader = \Maveriks\Util\ClassLoader::getInstance();
                    $loader->add($pluginSrcDir);
                }

                if (array_key_exists($detail->sNamespace, $this->_restServiceEnabled)
                    && $this->_restServiceEnabled[$detail->sNamespace] == true
                ) {

                    $oPlugin->registerRestService();
                }

                return true;
            }
        }
        throw new Exception( "Unable to enable plugin '$sNamespace' (plugin not found)" );
    }

    /**
     * disable the plugin in the singleton
     *
     * @param unknown_type $sNamespace
     */
    public function disablePlugin ($sNamespace, $eventPlugin = 1)
    {
        //require_once PATH_CORE . 'methods' . PATH_SEP . 'enterprise' . PATH_SEP . 'enterprise.php';
        $sw = false;
        //G::pr($this->_aPluginDetails);die;
        foreach ($this->_aPluginDetails as $namespace => $detail) {
            if ($namespace == $sNamespace) {
                //G::pr($detail);die;
                unset( $this->_aPluginDetails[$sNamespace] );

                if ($eventPlugin == 1) {
                    //$plugin = new $detail->sClassName( $detail->sNamespace, $detail->sFilename );
                    $this->_aPlugins[$detail->sNamespace] = $detail;
                    // If plugin class exists check if disable method exist,
                    // otherwise use default plugin details
                    if (class_exists($detail->sClassName)) {
                        $plugin = new $detail->sClassName($detail->sNamespace, $detail->sFilename);
                    } else {
                        $plugin = $detail;
                    }
                    if (method_exists($plugin, "disable")) {
                        $plugin->disable();
                    }
                }

                $sw = true;
            }
        }

        if (! $sw) {
            throw new Exception( "Unable to disable plugin '$sNamespace' (plugin not found)" );
        }

        foreach ($this->_aMenus as $key => $detail) {
            if ($detail->sNamespace == $sNamespace) {
                unset( $this->_aMenus[$key] );
            }
        }
        foreach ($this->_aFolders as $key => $detail) {
            if ($detail->sNamespace == $sNamespace) {
                unset( $this->_aFolders[$key] );
            }
        }
        foreach ($this->_aTriggers as $key => $detail) {
            if ($detail->sNamespace == $sNamespace) {
                unset( $this->_aTriggers[$key] );
            }
        }
        foreach ($this->_aDashlets as $key => $detail) {
            if ($detail == $sNamespace) {
                unset( $this->_aDashlets[$key] );
            }
        }
        foreach ($this->_aReports as $key => $detail) {
            if ($detail == $sNamespace) {
                unset( $this->_aReports[$key] );
            }
        }
        foreach ($this->_aPmFunctions as $key => $detail) {
            if ($detail == $sNamespace) {
                unset( $this->_aPmFunctions[$key] );
            }
        }
        foreach ($this->_aRedirectLogin as $key => $detail) {
            if ($detail->sNamespace == $sNamespace) {
                unset( $this->_aRedirectLogin[$key] );
            }
        }
        foreach ($this->_aSteps as $key => $detail) {
            if ($detail->sNamespace == $sNamespace) {
                unset( $this->_aSteps[$key] );
            }
        }
        foreach ($this->_aToolbarFiles as $key => $detail) {
            if ($detail->sNamespace == $sNamespace) {
                unset( $this->_aToolbarFiles[$key] );
            }
        }
        foreach ($this->_aCSSStyleSheets as $key => $detail) {
            if ($detail->sNamespace == $sNamespace) {
                unset( $this->_aCSSStyleSheets[$key] );
            }
        }
        foreach ($this->_aCaseSchedulerPlugin as $key => $detail) {
            if ($detail->sNamespace == $sNamespace) {
                unset( $this->_aCaseSchedulerPlugin[$key] );
            }
        }
        foreach ($this->_aTaskExtendedProperties as $key => $detail) {
            if ($detail->sNamespace == $sNamespace) {
                unset( $this->_aTaskExtendedProperties[$key] );
            }
        }
        foreach ($this->_aDashboardPages as $key => $detail) {
            if ($detail->sNamespace == $sNamespace) {
                unset( $this->_aDashboardPages[$key] );
            }
        }

        foreach ($this->_arrayDesignerMenu as $key => $detail) {
            if ($detail->pluginName == $sNamespace) {
                unset($this->_arrayDesignerMenu[$key]);
            }
        }
        
        foreach ($this->_arrayDesignerSourcePath as $key => $detail) {
            if ($detail->pluginName == $sNamespace) {
                unset($this->_arrayDesignerSourcePath[$key]);
            }
        }

        if(sizeof( $this->_aMenuOptionsToReplace )){
            unset( $this->_aMenuOptionsToReplace );
        }

        if(sizeof( $this->_aImportProcessCallbackFile )){
            unset( $this->_aImportProcessCallbackFile );
        }

        if(sizeof( $this->_aOpenReassignCallback )){
            unset( $this->_aOpenReassignCallback );
        }

        if (sizeof($this->_restExtendServices)) {
            $this->disableExtendsRestService($sNamespace);
        }
        //unregistering javascripts from this plugin
        $this->unregisterJavascripts( $sNamespace );
        //unregistering rest services from this plugin
        $this->unregisterRestService( $sNamespace );
    }

    /**
     * Get status plugin in the singleton
     *
     * @param string $name Plugin name
     *
     * return mixed Return a string with status plugin, 0 otherwise
     */
    public function getStatusPlugin($name)
    {
        try {
            return (isset($this->_aPluginDetails[$name]))? (($this->_aPluginDetails[$name]->enabled)? "enabled" : "disabled") : 0;
        } catch (Excepton $e) {
            throw $e;
        }
    }

    /**
     * Install a plugin archive.
     * If pluginName is specified, the archive will
     * only be installed if it contains this plugin.
     *
     * @return bool true if enabled, false otherwise
     */
    public function installPluginArchive ($filename, $pluginName)
    {

        $tar = new Archive_Tar( $filename );
        $files = $tar->listContent();
        $plugins = array ();
        $namePlugin = array ();
        foreach ($files as $f) {
            if (preg_match("/^([\w\.]*).ini$/", $f["filename"], $matches)) {
            //if (preg_match( "/^(.*pluginConfig)\.ini$/", $f["filename"], $matches )) {
                $plugins[] = $matches[1];
            }
            if (preg_match( "/^.*($pluginName)\.php$/", $f["filename"], $matches )) {
                $namePlugin[] = $matches[1];
            }
        }

        if (count( $plugins ) > 1) {
            throw new Exception( "Multiple plugins in one archive are not supported currently" );
        }

        //if (isset($pluginName) && !in_array($pluginName, $plugins)) {
        if (isset( $pluginName ) && ! in_array( $pluginName, $namePlugin )) {
            throw new Exception( "Plugin '$pluginName' not found in archive" );
        }

        //$pluginName = $plugins[0];
        $pluginFile = "$pluginName.php";

        /*
        $oldPluginStatus = $this->getStatusPlugin($pluginFile);

        if ($pluginStatus != 0) {
          $oldDetails = $this->getPluginDetails($pluginFile);
          $oldVersion = $oldDetails->iVersion;
        } else {
          $oldDetails = NULL;
          $oldVersion = NULL;
        }
        */

        //$pluginIni = $tar->extractInString("$pluginName.ini");
        //$pluginConfig = parse_ini_string($pluginIni);
        /*
        if (!empty($oClass->aDependences)) {
          foreach ($oClass->aDependences as $aDependence) {
            if (file_exists(PATH_PLUGINS . $aDependence['sClassName'] . '.php')) {
              require_once PATH_PLUGINS . $aDependence['sClassName'] . '.php';
              if (!$oPluginRegistry->getPluginDetails($aDependence['sClassName'] . '.php')) {
                throw new Exception('This plugin needs "' . $aDependence['sClassName'] . '" plugin');
              }
            }
            else {
              throw new Exception('This plugin needs "' . $aDependence['sClassName'] . '" plugin');
            }
          }
        }
        unset($oClass);
        if ($fVersionOld > $fVersionNew) {
          throw new Exception('A recent version of this plugin was already installed.');
        }
        */

        $res = $tar->extract( PATH_PLUGINS );
        if (! file_exists( PATH_PLUGINS . $pluginFile )) {
            throw (new Exception( "File \"$pluginFile\" doesn't exist" ));
        }

        $filter = new InputFilter();
        $path = PATH_PLUGINS . $pluginFile;
        //$path = $filter->validateInput($path, 'path');
        require_once ($path);
        $details = $this->getPluginDetails( $pluginFile );

        $this->installPlugin( $details->sNamespace );
        $this->setupPlugins();

        $this->enablePlugin( $details->sNamespace );
        $this->save();
    }

    public function uninstallPlugin ($sNamespace)
    {
        $pluginFile = $sNamespace . ".php";

        if (! file_exists( PATH_PLUGINS . $pluginFile )) {
            throw (new Exception( "File \"$pluginFile\" doesn't exist" ));
        }

        ///////
        $path = PATH_PLUGINS . $pluginFile;

        $filter = new InputFilter();
        $path = $filter->validateInput($path, 'path');
        require_once ($path);

        foreach ($this->_aPluginDetails as $namespace => $detail) {
            if ($namespace == $sNamespace) {
                $this->enablePlugin( $detail->sNamespace );
                $this->disablePlugin( $detail->sNamespace );

                ///////
                $plugin = new $detail->sClassName( $detail->sNamespace, $detail->sFilename );
                $this->_aPlugins[$detail->sNamespace] = $plugin;

                if (method_exists( $plugin, "uninstall" )) {
                    $plugin->uninstall();
                }

                ///////
                $this->save();
                ///////
                $pluginDir = PATH_PLUGINS . $detail->sPluginFolder;

                if (isset( $detail->sFilename ) && ! empty( $detail->sFilename ) && file_exists( $detail->sFilename )) {
                    unlink( $detail->sFilename );
                }

                if (isset( $detail->sPluginFolder ) && ! empty( $detail->sPluginFolder ) && file_exists( $pluginDir )) {
                    G::rm_dir( $pluginDir );
                }

                ///////
                $this->uninstallPluginWorkspaces( array ($sNamespace
                ) );
                ///////
                break;
            }
        }
    }

    public function uninstallPluginWorkspaces ($arrayPlugin)
    {
        $workspace = PmSystem::listWorkspaces();

        foreach ($workspace as $indexWS => $ws) {
            $wsPathDataSite = PATH_DATA . "sites" . PATH_SEP . $ws->name . PATH_SEP;

            if (file_exists( $wsPathDataSite . "plugin.singleton" )) {

                $pluginRegistry = &PMPluginRegistry::getSingleton();
                $pluginRegistry->unSerializeInstance( file_get_contents( $wsPathDataSite . "plugin.singleton" ) );

                ///////
                $attributes = $pluginRegistry->getAttributes();

                foreach ($arrayPlugin as $index => $value) {
                    if (isset( $attributes["_aPluginDetails"][$value] )) {
                        $pluginRegistry->disablePlugin( $value, 0 );
                    }
                }

                ///////
                file_put_contents( $wsPathDataSite . "plugin.singleton", $pluginRegistry->serializeInstance() );
            }
        }
    }

    /**
     * install the plugin
     *
     * @param unknown_type $sNamespace
     */
    public function installPlugin ($sNamespace)
    {
        try {
            foreach ($this->_aPluginDetails as $namespace => $detail) {
                if ($sNamespace == $namespace) {
                    $oPlugin = new $detail->sClassName( $detail->sNamespace, $detail->sFilename );
                    $this->_aPlugins[$detail->sNamespace] = $oPlugin;
                    $oPlugin->install();
                }
            }
        } catch (Exception $e) {
            global $G_PUBLISH;
            $aMessage['MESSAGE'] = $e->getMessage();
            $G_PUBLISH = new Publisher();
            $G_PUBLISH->AddContent( 'xmlform', 'xmlform', 'login/showMessage', '', $aMessage );
            G::RenderPage( 'publish' );
            die();
        }

    }

    /**
     * Register a menu in the singleton
     *
     * @param unknown_type $sNamespace
     * @param unknown_type $sMenuId
     * @param unknown_type $sFilename
     */
    public function registerMenu ($sNamespace, $sMenuId, $sFilename)
    {
        $found = false;
        foreach ($this->_aMenus as $row => $detail) {
            if ($sMenuId == $detail->sMenuId && $sNamespace == $detail->sNamespace) {
                $found = true;
            }
        }
        if (! $found) {
            $menuDetail = new menuDetail( $sNamespace, $sMenuId, $sFilename );
            $this->_aMenus[] = $menuDetail;
        }
    }

    /**
     * Register a dashlet class in the singleton
     *
     * @param unknown_type $className
     */
    public function registerDashlets ($namespace)
    {
        $found = false;
        foreach ($this->_aDashlets as $row => $detail) {
            if ($namespace == $detail) {
                $found = true;
            }
        }
        if (! $found) {
            $this->_aDashlets[] = $namespace;
        }
    }

    /**
     * Register a stylesheet in the singleton
     *
     * @param unknown_type $sNamespace
     * @param unknown_type $sPage
     */
    public function registerCss ($sNamespace, $sCssFile)
    {
        $found = false;
        foreach ($this->_aCSSStyleSheets as $row => $detail) {
            if ($sCssFile == $detail->sCssFile && $sNamespace == $detail->sNamespace) {
                $detail->sCssFile = $sCssFile;
                $found = true;
            }
        }
        if (! $found) {
            $cssFile = new cssFile( $sNamespace, $sCssFile );
            $this->_aCSSStyleSheets[] = $cssFile;
        }
    }

    /**
     * return all css
     *
     * @return array
     */
    public function getRegisteredCss ()
    {
        return $this->_aCSSStyleSheets;
    }

    /**
     * Register a plugin javascript to run with core js script at same runtime
     *
     * @param string $sNamespace
     * @param string $coreJsFile
     * @param array/string $pluginJsFile
     */
    public function registerJavascript ($sNamespace, $sCoreJsFile, $pluginJsFile)
    {

        foreach ($this->_aJavascripts as $i => $js) {
            if ($sCoreJsFile == $js->sCoreJsFile && $sNamespace == $js->sNamespace) {
                if (is_string( $pluginJsFile )) {
                    if (! in_array( $pluginJsFile, $this->_aJavascripts[$i]->pluginJsFile )) {
                        $this->_aJavascripts[$i]->pluginJsFile[] = $pluginJsFile;
                    }
                } elseif (is_array( $pluginJsFile )) {
                    $this->_aJavascripts[$i]->pluginJsFile = array_unique( array_merge( $pluginJsFile, $this->_aJavascripts[$i]->pluginJsFile ) );
                } else {
                    throw new Exception( 'Invalid third param, $pluginJsFile should be a string or array - ' . gettype( $pluginJsFile ) . ' given.' );
                }
                return $this->_aJavascripts[$i];
            }
        }

        $js = new StdClass();
        $js->sNamespace = $sNamespace;
        $js->sCoreJsFile = $sCoreJsFile;
        $js->pluginJsFile = Array ();

        if (is_string( $pluginJsFile )) {
            $js->pluginJsFile[] = $pluginJsFile;
        } elseif (is_array( $pluginJsFile )) {
            $js->pluginJsFile = array_merge( $js->pluginJsFile, $pluginJsFile );
        } else {
            throw new Exception( 'Invalid third param, $pluginJsFile should be a string or array - ' . gettype( $pluginJsFile ) . ' given.' );
        }

        $this->_aJavascripts[] = $js;
    }

    /**
     * return all plugin javascripts
     *
     * @return array
     */
    public function getRegisteredJavascript ()
    {
        return $this->_aJavascripts;
    }

    /**
     * return all plugin javascripts given a core js file, from all namespaces or a single namespace
     *
     * @param string $sCoreJsFile
     * @param string $sNamespace
     * @return array
     */
    public function getRegisteredJavascriptBy ($sCoreJsFile, $sNamespace = '')
    {
        $scripts = array ();

        if ($sNamespace == '') {
            foreach ($this->_aJavascripts as $i => $js) {
                if ($sCoreJsFile == $js->sCoreJsFile) {
                    $scripts = array_merge( $scripts, $this->_aJavascripts[$i]->pluginJsFile );
                }
            }
        } else {
            foreach ($this->_aJavascripts as $i => $js) {
                if ($sCoreJsFile == $js->sCoreJsFile && $sNamespace == $js->sNamespace) {
                    $scripts = array_merge( $scripts, $this->_aJavascripts[$i]->pluginJsFile );
                }
            }
        }
        return $scripts;
    }

    /**
     * unregister all javascripts from a namespace or a js core file given
     *
     * @param string $sNamespace
     * @param string $sCoreJsFile
     * @return array
     */
    public function unregisterJavascripts ($sNamespace, $sCoreJsFile = '')
    {
        if ($sCoreJsFile == '') {
            // if $sCoreJsFile=='' unregister all js from this namespace
            foreach ($this->_aJavascripts as $i => $js) {
                if ($sNamespace == $js->sNamespace) {
                    unset( $this->_aJavascripts[$i] );
                }
            }
            // Re-index when all js were unregistered
            $this->_aJavascripts = array_values( $this->_aJavascripts );
        } else {
            foreach ($this->_aJavascripts as $i => $js) {
                if ($sCoreJsFile == $js->sCoreJsFile && $sNamespace == $js->sNamespace) {
                    unset( $this->_aJavascripts[$i] );
                    // Re-index for each js that was unregistered
                    $this->_aJavascripts = array_values( $this->_aJavascripts );
                }
            }
        }
    }

    /**
     * Register a reports class in the singleton
     *
     * @param unknown_type $sNamespace
     * @param unknown_type $sMenuId
     * @param unknown_type $sFilename
     */
    public function registerReport ($sNamespace)
    {
        $found = false;
        foreach ($this->_aReports as $row => $detail) {
            if ($sNamespace == $detail) {
                $found = true;
            }
        }
        if (! $found) {
            $this->_aReports[] = $sNamespace;
        }
    }

    /**
     * Register a PmFunction class in the singleton
     *
     * @param unknown_type $sNamespace
     * @param unknown_type $sMenuId
     * @param unknown_type $sFilename
     */
    public function registerPmFunction ($sNamespace)
    {
        $found = false;
        foreach ($this->_aPmFunctions as $row => $detail) {
            if ($sNamespace == $detail) {
                $found = true;
            }
        }
        if (! $found) {
            $this->_aPmFunctions[] = $sNamespace;
        }
    }

    /**
     * Register a redirectLogin class in the singleton
     *
     * @param unknown_type $sNamespace
     * @param unknown_type $sRole
     * @param unknown_type $sPath
     */
    public function registerRedirectLogin ($sNamespace, $sRole, $sPathMethod)
    {
        $found = false;
        foreach ($this->_aRedirectLogin as $row => $detail) {
            if (($sNamespace == $detail->sNamespace) && ($sRole == $detail->sRoleCode)) {
                //Filters based on Workspace and Role Code
                $found = true;
            }
        }
        if (! $found) {
            $this->_aRedirectLogin[] = new redirectDetail( $sNamespace, $sRole, $sPathMethod );
        }
    }

    /**
     * Register a folder for methods
     *
     * @param unknown_type $sFolderName
     */
    public function registerFolder ($sNamespace, $sFolderId, $sFolderName)
    {
        $found = false;
        foreach ($this->_aFolders as $row => $detail) {
            if ($sFolderId == $detail->sFolderId && $sNamespace == $detail->sNamespace) {
                $found = true;
            }
        }

        if (! $found) {
            $this->_aFolders[] = new folderDetail( $sNamespace, $sFolderId, $sFolderName );
        }
    }

    /**
     * Register a step for process
     *
     * @param unknown_type $sFolderName
     */
    public function registerStep ($sNamespace, $sStepId, $sStepName, $sStepTitle, $setupStepPage = '')
    {
        $found = false;
        foreach ($this->_aSteps as $row => $detail) {
            if ($sStepId == $detail->sStepId && $sNamespace == $detail->sNamespace) {
                $found = true;
            }
        }

        if (! $found) {
            $this->_aSteps[] = new stepDetail( $sNamespace, $sStepId, $sStepName, $sStepTitle, $setupStepPage );
        }
    }

    /**
     * return true if the $sFolderName is registered in the singleton
     *
     * @param unknown_type $sFolderName
     */
    public function isRegisteredFolder ($sFolderName)
    {
        foreach ($this->_aFolders as $row => $folder) {
            if ($sFolderName == $folder->sFolderName && is_dir( PATH_PLUGINS . $folder->sFolderName )) {
                return true;
            } elseif ($sFolderName == $folder->sFolderName && is_dir( PATH_PLUGINS . $folder->sNamespace . PATH_SEP . $folder->sFolderName )) {
                return $folder->sNamespace;
            }
        }
        return false;
    }

    /**
     * return all menus related to a menuId
     *
     * @param unknown_type $menuId
     */
    public function getMenus ($menuId)
    {
        foreach ($this->_aMenus as $row => $detail) {
            if ($menuId == $detail->sMenuId && file_exists( $detail->sFilename )) {
                include ($detail->sFilename);
            }
        }
    }

    /**
     * return all dashlets classes registered
     *
     * @return array
     */
    public function getDashlets ()
    {
        return $this->_aDashlets;
    }

    /**
     * this function returns all reports registered
     *
     * @return array
     */
    public function getReports ()
    {
        return $this->_aReports;
        $report = array ();
        foreach ($this->_aReports as $row => $detail) {
            $sClassName = str_replace( 'plugin', 'class', $this->_aPluginDetails[$detail]->sClassName );
            $report[] = $sClassName;
        }
        return $report;
    }

    /**
     * This function returns all pmFunctions registered
     * @ array
     */
    public function getPmFunctions ()
    {
        return $this->_aPmFunctions;
        $pmf = array ();
        foreach ($this->_aPmFunctions as $row => $detail) {
            $sClassName = str_replace( 'plugin', 'class', $this->_aPluginDetails[$detail]->sClassName );
            $pmf[] = $sClassName;
        }
        return $pmf;
    }

    /**
     * This function returns all steps registered
     *
     * @return string
     */
    public function getSteps ()
    {
        return $this->_aSteps;
    }

    /**
     * This function returns all redirect registered
     *
     * @return string
     */
    public function getRedirectLogins ()
    {
        return $this->_aRedirectLogin;
    }

    /**
     * execute all triggers related to a triggerId
     *
     * @param unknown_type $menuId
     * @return object
     */
    public function executeTriggers ($triggerId, $oData)
    {

        foreach ($this->_aTriggers as $row => $detail) {
            if ($triggerId == $detail->sTriggerId) {
                //review all folders registered for this namespace
                $found = false;
                $classFile = '';

                foreach ($this->_aFolders as $row => $folder) {
                    $fname = $folder->sNamespace == 'enterprise' ? PATH_CORE . 'classes' . PATH_SEP . 'class.' . $folder->sFolderName . '.php' : PATH_PLUGINS . $folder->sFolderName . PATH_SEP . 'class.' . $folder->sFolderName . '.php';
                    if ($detail->sNamespace == $folder->sNamespace && file_exists( $fname )) {
                        $found = true;
                        $classFile = $fname;
                    }
                }
                if ($found) {
                    require_once ($classFile);
                    $sClassName = substr( $this->_aPluginDetails[$detail->sNamespace]->sClassName, 0, 1 ) . str_replace( 'plugin', 'class', substr( $this->_aPluginDetails[$detail->sNamespace]->sClassName, 1 ) );
                    $obj = new $sClassName();
                    $methodName = $detail->sTriggerName;
                    $response = $obj->{$methodName}( $oData );
                    if (PEAR::isError( $response )) {
                        print $response->getMessage();
                        return;
                    }
                    return $response;
                } else {
                    print "error in call method " . $detail->sTriggerName;
                }
            }
        }
    }

    /**
     * verify if exists triggers related to a triggerId
     *
     * @param unknown_type $triggerId
     */
    public function existsTrigger ($triggerId)
    {
        $found = false;
        foreach ($this->_aTriggers as $row => $detail) {
            if ($triggerId == $detail->sTriggerId) {
                //review all folders registered for this namespace
                foreach ($this->_aFolders as $row => $folder) {
                    $fname = $folder->sNamespace == 'enterprise' ? PATH_CORE . 'classes' . PATH_SEP . 'class.' . $folder->sFolderName . '.php' : PATH_PLUGINS . $folder->sFolderName . PATH_SEP . 'class.' . $folder->sFolderName . '.php';
                    if ($detail->sNamespace == $folder->sNamespace && file_exists( $fname )) {
                        $found = true;
                    }
                }

            }
        }
        return $found;
    }

    /**
     * Return info related to a triggerId
     *
     * @param unknown_type $triggerId
     * @return object
     */
    public function getTriggerInfo ($triggerId)
    {
        $found = null;
        foreach ($this->_aTriggers as $row => $detail) {
            if ($triggerId == $detail->sTriggerId) {
                //review all folders registered for this namespace
                foreach ($this->_aFolders as $row => $folder) {
                    $fname = PATH_PLUGINS . $folder->sFolderName . PATH_SEP . 'class.' . $folder->sFolderName . '.php';
                    if ($detail->sNamespace == $folder->sNamespace && file_exists( $fname )) {
                        $found = $detail;
                    }
                }
            }
        }
        return $found;
    }

    /**
     * Register a trigger in the Singleton
     *
     * @param unknown_type $sTriggerId
     * @param unknown_type $sMethodFunction
     * @return void
     */
    public function registerTrigger ($sNamespace, $sTriggerId, $sTriggerName)
    {
        $found = false;
        foreach ($this->_aTriggers as $row => $detail) {
            if ($sTriggerId == $detail->sTriggerId && $sNamespace == $detail->sNamespace) {
                $found = true;
            }
        }
        if (! $found) {
            $triggerDetail = new triggerDetail( $sNamespace, $sTriggerId, $sTriggerName );
            $this->_aTriggers[] = $triggerDetail;
        }
    }

    /**
     * get plugin
     *
     * @param unknown_type $sNamespace
     * @return void
     */
    public function &getPlugin ($sNamespace)
    {
        $oPlugin = null;
        if (array_key_exists( $sNamespace, $this->_aPlugins )) {
            $oPlugin = $this->_aPlugins[$sNamespace];
        }
        /*
        $aDetails = KTUtil::arrayGet($this->_aPluginDetails, $sNamespace);
        if (empty($aDetails)) {
            return null;
        }
        $sFilename = $aDetails[2];
        if (!empty($sFilename)) {
            require_once($sFilename);
        }
        $sClassName = $aDetails[0];
        $oPlugin =& new $sClassName($sFilename);
        $this->_aPlugins[$sNamespace] =& $oPlugin;
        return $oPlugin;
        */
        return $oPlugin;
    }

    /**
     * set company logo
     *
     * @param unknown_type $sNamespace
     * @param unknown_type $filename
     * @return void
     */
    public function setCompanyLogo ($sNamespace, $filename)
    {
        $found = false;
        foreach ($this->_aPluginDetails as $row => $detail) {
            if ($sNamespace == $detail->sNamespace) {
                $this->_aPluginDetails[$sNamespace]->sCompanyLogo = $filename;
            }
        }
    }

    /**
     * get company logo
     *
     * @param unknown_type $default
     * @return void
     */
    public function getCompanyLogo ($default)
    {
        $sCompanyLogo = $default;
        foreach ($this->_aPluginDetails as $row => $detail) {
            if (trim( $detail->sCompanyLogo ) != '') {
                $sCompanyLogo = $detail->sCompanyLogo;
            }
        }
        return $sCompanyLogo;
    }

    /**
     * get setup Plugins
     *
     * @param unknown_type $default
     * @return void
     */
    public function setupPlugins ()
    {
        try {
            $iPlugins = 0;
            $oServerConf = & ServerConf::getSingleton();
            $oServerConf->addPlugin( SYS_SYS, $this->_aPluginDetails );
            foreach ($this->_aPluginDetails as $namespace => $detail) {
                if (isset( $detail->enabled ) && $detail->enabled) {
                    if (! empty( $detail->sFilename ) && file_exists( $detail->sFilename )) {
                        $arrayFileInfo = pathinfo($detail->sFilename);
                        $sFilename = (($detail->sNamespace == "enterprise")? PATH_CORE. "methods" . PATH_SEP . "enterprise" . PATH_SEP : PATH_PLUGINS) . $arrayFileInfo["basename"];
                        if (! file_exists( $sFilename )) {
                            continue;
                        }
                        require_once $sFilename;
                        if (class_exists( $detail->sClassName )) {
                            $oPlugin = new $detail->sClassName( $detail->sNamespace, $detail->sFilename );
                            $this->_aPlugins[$detail->sNamespace] = $oPlugin;
                            $iPlugins ++;
                            $oPlugin->setup();
                        }
                    }
                }
            }
            $this->eevalidate();
            return $iPlugins;
        } catch (Exception $e) {
            global $G_PUBLISH;
            $aMessage['MESSAGE'] = $e->getMessage();
            $G_PUBLISH = new Publisher();
            $G_PUBLISH->AddContent( 'xmlform', 'xmlform', 'login/showMessage', '', $aMessage );
            G::RenderPage( 'publish' );
            die();
        }
    }

    /**
     * this function execute a Method
     *
     * @param string $sNamespace
     * @param string $methodName
     * @param object $oData
     * @return object
     */
    public function executeMethod ($sNamespace, $methodName, $oData)
    {
        $response = null;
        try {
            $details = $this->_aPluginDetails[$sNamespace];
            $pluginFolder = $details->sPluginFolder;
            $className = $details->sClassName;
            $classFile = PATH_PLUGINS . $pluginFolder . PATH_SEP . 'class.' . $pluginFolder . '.php';
            if (file_exists( $classFile )) {
                $sClassName = substr_replace( $className, "class", - 6, 6 );
                //$sClassName = str_replace ( 'plugin', 'class', $className );
                if (! class_exists( $sClassName )) {
                    require_once $classFile;
                }
                $obj = new $sClassName();
                if (! in_array( $methodName, get_class_methods( $obj ) )) {
                    throw (new Exception( "The method '$methodName' doesn't exist in class '$sClassName' " ));
                }
                $obj->sNamespace = $details->sNamespace;
                $obj->sClassName = $details->sClassName;
                $obj->sFilename = $details->sFilename;
                $obj->iVersion = $details->iVersion;
                $obj->sFriendlyName = $details->sFriendlyName;
                $obj->sPluginFolder = $details->sPluginFolder;
                $response = $obj->{$methodName}( $oData );
            }
            return $response;
        } catch (Exception $e) {
            throw ($e);
        }
    }

    /**
     * this function gets Fields For Page on Setup
     *
     * @param string $sNamespace
     * @return object
     */
    public function getFieldsForPageSetup ($sNamespace)
    {
        $oData = null;
        return $this->executeMethod( $sNamespace, 'getFieldsForPageSetup', $oData );
    }

    /**
     * this function updates Fields For Page on Setup
     *
     * @param string $sNamespace
     * @return void
     */
    public function updateFieldsForPageSetup ($sNamespace, $oData)
    {
        if (! isset( $this->_aPluginDetails[$sNamespace] )) {
            throw (new Exception( "The namespace '$sNamespace' doesn't exist in plugins folder." ));
        }

        return $this->executeMethod( $sNamespace, 'updateFieldsForPageSetup', $oData );
    }

    public function eevalidate ()
    {
        $fileL = PATH_DATA_SITE . 'license.dat';
        $fileS = PATH_DATA . 'license.dat';
        if ((file_exists( $fileL )) || (file_exists( $fileS ))) {
            //Found a License
            if (class_exists( 'pmLicenseManager' )) {
                $sSerializedFile = PATH_DATA_SITE . 'lmn.singleton';
                $pmLicenseManagerO = & PmLicenseManager::getSingleton();
                if (file_exists( $sSerializedFile )) {
                    $pmLicenseManagerO->unSerializeInstance( file_get_contents( $sSerializedFile ) );
                }
            }
        }
    }

    /**
     * Register a toolbar for dynaform editor in the singleton
     *
     * @param unknown_type $sNamespace
     * @param unknown_type $sToolbarId
     * @param unknown_type $sFilename
     */
    public function registerToolbarFile ($sNamespace, $sToolbarId, $sFilename)
    {
        $found = false;
        foreach ($this->_aToolbarFiles as $row => $detail) {
            if ($sToolbarId == $detail->sToolbarId && $sNamespace == $detail->sNamespace) {
                $found = true;
            }
        }
        if (! $found) {
            $toolbarDetail = new toolbarDetail( $sNamespace, $sToolbarId, $sFilename );
            $this->_aToolbarFiles[] = $toolbarDetail;
        }
    }

    /**
     * return all toolbar files related to a sToolbarId
     *
     * @param unknown_type $sToolbarId (NORMAL, GRID)
     */
    public function getToolbarOptions ($sToolbarId)
    {
        foreach ($this->_aToolbarFiles as $row => $detail) {
            if ($sToolbarId == $detail->sToolbarId && file_exists( $detail->sFilename )) {
                include ($detail->sFilename);
            }
        }
    }

    /**
     * Register a Case Scheduler Plugin
     */
    public function registerCaseSchedulerPlugin ($sNamespace, $sActionId, $sActionForm, $sActionSave, $sActionExecute, $sActionGetFields)
    {
        $found = false;
        foreach ($this->_aCaseSchedulerPlugin as $row => $detail) {
            if ($sActionId == $detail->sActionId && $sNamespace == $detail->sNamespace) {
                $found = true;
            }
        }

        if (! $found) {
            $this->_aCaseSchedulerPlugin[] = new caseSchedulerPlugin( $sNamespace, $sActionId, $sActionForm, $sActionSave, $sActionExecute, $sActionGetFields );
        }
    }

    /**
     * This function returns all Case Scheduler Plugins registered
     *
     * @return string
     */
    public function getCaseSchedulerPlugins ()
    {
        return $this->_aCaseSchedulerPlugin;
    }

    /**
     * Register a Task Extended property page in the singleton
     *
     * @param unknown_type $sNamespace
     * @param unknown_type $sPage
     */

    public function registerTaskExtendedProperty ($sNamespace, $sPage, $sName, $sIcon)
    {
        $found = false;
        foreach ($this->_aTaskExtendedProperties as $row => $detail) {
            if ($sPage == $detail->sPage && $sNamespace == $detail->sNamespace) {
                $detail->sName = $sName;
                $detail->sIcon = $sIcon;
                $found = true;
            }
        }
        if (! $found) {
            $taskExtendedProperty = new taskExtendedProperty( $sNamespace, $sPage, $sName, $sIcon );
            $this->_aTaskExtendedProperties[] = $taskExtendedProperty;
        }
    }

    /**
     * Register a dashboard page for cases in the singleton
     *
     * @param unknown_type $sNamespace
     * @param unknown_type $sPage
     * @param unknown_type $sName
     * @param unknown_type $sIcon
     */
    public function registerDashboardPage ($sNamespace, $sPage, $sName, $sIcon)
    {
        foreach ($this->_aDashboardPages as $row => $detail) {
            if ($sPage == $detail->sPage && $sNamespace == $detail->sNamespace) {
                $detail->sName = $sName;
                $detail->sIcon = $sIcon;
                $found = true;
            }
        }
        if (! $found) {
            $dashboardPage = new dashboardPage( $sNamespace, $sPage, $sName, $sIcon );
            $this->_aDashboardPages[] = $dashboardPage;
        }
    }

    /**
     * Register a rest service class from a plugin to be served by processmaker
     *
     * @param string $sNamespace The namespace for the plugin
     * @param string $classname The service (api) class name
     * @param string $path (optional) the class file path, if it is not set the system will try resolve the
     * file path from its classname.
     */
    public function registerRestService($sNamespace)
    {
        $baseSrcPluginPath = PATH_PLUGINS . $sNamespace . PATH_SEP . "src";
        $apiPath = PATH_SEP . "Services" . PATH_SEP . "Api" . PATH_SEP . ucfirst($sNamespace);
        $classesList = Bootstrap::rglob('*', 0, $baseSrcPluginPath . $apiPath);

        foreach ($classesList as $classFile) {
            if (pathinfo($classFile, PATHINFO_EXTENSION) === 'php') {
                $ns = str_replace(
                    '/',
                    '\\',
                    str_replace('.php', '', str_replace($baseSrcPluginPath, '', $classFile))
                );

                // Ensure that is registering only existent classes.
                if (class_exists($ns)) {
                    $this->_restServices[$sNamespace][] = array(
                        "filepath" => $classFile,
                        "namespace" => $ns
                    );
                }
            }
        }

        \Maveriks\WebApplication::purgeRestApiCache(basename(PATH_DATA_SITE));

        return true;
    }

    /**
     * Register a extend rest service class from a plugin to be served by processmaker
     *
     * @param string $sNamespace The namespace for the plugin
     * @param string $className The service (api) class name
     */
    public function registerExtendsRestService($sNamespace, $className)
    {
        $baseSrcPluginPath = PATH_PLUGINS . $sNamespace . PATH_SEP . "src";
        $apiPath = PATH_SEP . "Services" . PATH_SEP . "Ext" . PATH_SEP;
        $classFile = $baseSrcPluginPath . $apiPath . 'Ext' . $className . '.php';
        if (file_exists($classFile)) {
            $this->_restExtendServices[$sNamespace][$className] = array(
                "filePath" => $classFile,
                "classParent" => $className,
                "classExtend" => 'Ext' . $className
            );
        }
    }

    /**
     * Get a extend rest service class from a plugin to be served by processmaker
     *
     * @param string $className The service (api) class name
     * @return array
     */
    public function getExtendsRestService($className)
    {
        $responseRestExtendService = array();
        foreach ($this->_restExtendServices as $sNamespace => $restExtendService) {
            if (isset($restExtendService[$className])) {
                $responseRestExtendService = $restExtendService[$className];
                break;
            }
        }
        return $responseRestExtendService;
    }

    /**
     * Remove a extend rest service class from a plugin to be served by processmaker
     *
     * @param string $sNamespace
     * @param string $className The service (api) class name
     * @return bool
     */
    public function disableExtendsRestService($sNamespace, $className = '')
    {
        if (isset($this->_restExtendServices[$sNamespace][$className]) && !empty($className)) {
            unset($this->_restExtendServices[$sNamespace][$className]);
        } elseif (empty($className)) {
            unset($this->_restExtendServices[$sNamespace]);
        }
    }

    /**
     * Unregister a rest service class of a plugin
     *
     * @param string $sNamespace The namespace for the plugin
     */
    public function unregisterRestService ($sNamespace)
    {
        unset($this->_restServices[$sNamespace]);
        \Maveriks\WebApplication::purgeRestApiCache(basename(PATH_DATA_SITE));
    }

    public function getRegisteredRestServices()
    {
        return $this->_restServices;
    }

    /**
     * return all dashboard pages
     *
     * @return array
     */
    public function getDashboardPages ()
    {
        return $this->_aDashboardPages;
    }

    /**
     * return all tasl extended properties
     *
     * @return array
     */
    public function getTaskExtendedProperties ()
    {
        return $this->_aTaskExtendedProperties;
    }

    public function registerDashboard ()
    {
        // Dummy function for backwards compatibility
    }

    public function getAttributes ()
    {
        return get_object_vars( $this );
    }

    public function verifyTranslation ($namePlugin)
    {
        $language = new Language();
        $pathPluginTranslations = PATH_PLUGINS . $namePlugin . PATH_SEP . 'translations' . PATH_SEP;
        if (file_exists($pathPluginTranslations . 'translations.php')) {
            if (!file_exists($pathPluginTranslations . $namePlugin . '.' . SYS_LANG . '.po')) {
                $language->createLanguagePlugin($namePlugin, SYS_LANG);
            }
            $language->updateLanguagePlugin($namePlugin, SYS_LANG);
        }
    }

    /**
     * Register a cron file in the singleton
     *
     * @param unknown_type $namespace
     * @param unknown_type $cronFile
     */
    public function registerCronFile ($namespace, $cronFile)
    {
        $found = false;
        foreach ($this->_aCronFiles as $row => $detail) {
            if ($cronFile == $detail->cronFile && $namespace == $detail->namespace) {
                $detail->cronFile = $cronFile;
                $found = true;
            }
        }
        if (!$found) {
            $cronFile = new cronFile( $namespace, $cronFile );
            $this->_aCronFiles[] = $cronFile;
        }
    }

    /**
     * Function to enable rest service for plugins
     * @param string $sNamespace
     * @param bool $enable
     */
    function enableRestService($sNamespace, $enable)
    {
        $this->_restServiceEnabled[$sNamespace] = $enable;
    }

    /**
     * Return all cron files registered
     *
     * @return array
     */
    public function getCronFiles()
    {
        return $this->_aCronFiles;
    }

    /**
     * Update the plugin attributes in all workspaces
     *
     * @param string $pluginName Plugin name
     *
     * return void
     */
    public function updatePluginAttributesInAllWorkspaces($pluginName)
    {
        try {

            //Set variables
            $pluginFileName = $pluginName . ".php";

            //Verify data
            if (!file_exists(PATH_PLUGINS . $pluginFileName)) {
                throw new Exception("Error: The plugin not exists");
            }

            //Update plugin attributes
            require_once(PATH_PLUGINS . $pluginFileName);

            $pmPluginRegistry = &PMPluginRegistry::getSingleton();

            $pluginDetails = $pmPluginRegistry->getPluginDetails($pluginFileName);

            if (isset($pluginDetails->aWorkspaces) && is_array($pluginDetails->aWorkspaces) && count($pluginDetails->aWorkspaces) > 0) {
                $arrayWorkspace = array();

                foreach (PmSystem::listWorkspaces() as $value) {
                    $workspaceTools = $value;

                    $arrayWorkspace[] = $workspaceTools->name;
                }

                $arrayWorkspaceAux = array_diff($arrayWorkspace, $pluginDetails->aWorkspaces); //Workspaces to update
                $strWorkspaceNoWritable = "";

                $arrayWorkspace = array();

                foreach ($arrayWorkspaceAux as $value) {
                    $workspace = $value;

                    $workspacePathDataSite = PATH_DATA . "sites" . PATH_SEP . $workspace . PATH_SEP;

                    if (file_exists($workspacePathDataSite . "plugin.singleton")) {
                        $pmPluginRegistry = PMPluginRegistry::loadSingleton($workspacePathDataSite . "plugin.singleton");

                        if (isset($pmPluginRegistry->_aPluginDetails[$pluginName])) {
                            if (!is_writable($workspacePathDataSite . "plugin.singleton")) {
                                $strWorkspaceNoWritable .= (($strWorkspaceNoWritable != "")? ", " : "") . $workspace;
                            }

                            $arrayWorkspace[] = $workspace;
                        }
                    }
                }

                //Verify data
                if ($strWorkspaceNoWritable != "") {
                    throw new Exception("Error: The workspaces \"$strWorkspaceNoWritable\" has problems of permissions of write in file \"plugin.singleton\", solve this problem");
                }

                //Update plugin attributes
                foreach ($arrayWorkspace as $value) {
                    $workspace = $value;

                    $workspacePathDataSite = PATH_DATA . "sites" . PATH_SEP . $workspace . PATH_SEP;

                    $pmPluginRegistry = PMPluginRegistry::loadSingleton($workspacePathDataSite . "plugin.singleton");

                    $pmPluginRegistry->disablePlugin($pluginName);

                    file_put_contents($workspacePathDataSite . "plugin.singleton", $pmPluginRegistry->serializeInstance());
                }
            }
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Register designer menu file
     *
     * @param string $pluginName Plugin name
     * @param string $file       Designer menu file
     *
     * @return void
     */
    public function registerDesignerMenu($pluginName, $file)
    {
        try {
            $flagFound = false;

            foreach ($this->_arrayDesignerMenu as $value) {
                if ($value->pluginName == $pluginName && $value->file == $file) {
                    $flagFound = true;
                    break;
                }
            }

            if (!$flagFound) {
                $obj = new stdClass();
                $obj->pluginName = $pluginName;
                $obj->file = $file;

                $this->_arrayDesignerMenu[] = $obj;
            }
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Return all designer menu files registered
     *
     * @return array
     */
    public function getDesignerMenu()
    {
        try {
            return $this->_arrayDesignerMenu;
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Replace new options to menu
     *
     * @param unknown_type $namespace
     *
     * @param array $from
     *
     * @param array $options
     *
     * @return void
     */
    public function registerMenuOptionsToReplace ($namespace, $from, $options)
    {
        if(isset($from["section"]) && isset($from["menuId"])) {
            $section = $from["section"];
            $oMenuFromPlugin = $this->_aMenuOptionsToReplace;
            if(array_key_exists($section,$oMenuFromPlugin)) {
                unset($this->_aMenuOptionsToReplace[$from["section"]]);
            }
            $this->_aMenuOptionsToReplace[$from["section"]][$from["menuId"]][] = $options;
        }
    }

    /**
     * Return all menu Options from a specific section
     *
     * @return array
     */
    public function getMenuOptionsToReplace($strMenuName)
    {
        $oMenuFromPlugin = $this->_aMenuOptionsToReplace;
        if(sizeof($oMenuFromPlugin)) {
            if(array_key_exists($strMenuName,$oMenuFromPlugin)) {
                return $oMenuFromPlugin[$strMenuName];
            }
        }
    }

    /**
     * Register a callBackFile in the singleton
     *
     * @param unknown_type $namespace
     *
     * @param string $callBackFile
     *
     * @return void
     */
    public function registerImportProcessCallback ($namespace, $callBackFile)
    {
        try {
            $found = false;
            foreach ($this->_aImportProcessCallbackFile as $row => $detail) {
                if ($callBackFile == $detail->callBackFile && $namespace == $detail->namespace) {
                    $detail->callBackFile = $callBackFile;
                    $found = true;
                }
            }
            if (!$found) {
                $callBackFile = new importCallBack( $namespace, $callBackFile );
                $this->_aImportProcessCallbackFile[] = $callBackFile;
            }
        } catch(Excepton $e) {
            throw $e;
        }
    }

    /**
     * Return all callBackFiles registered
     *
     * @return array
     */
    public function getImportProcessCallback()
    {
        return $this->_aImportProcessCallbackFile;
    }

    /**
     * Register a callBackFile in the singleton
     *
     * @param string $callBackFile
     *
     * @return void
     */
    public function registerOpenReassignCallback ($callBackFile)
    {
        try {
            $found = false;
            foreach ($this->_aOpenReassignCallback as $row => $detail) {
                if ($callBackFile == $detail->callBackFile) {
                    $detail->callBackFile = $callBackFile;
                    $found = true;
                }
            }
            if (!$found) {
                $callBackFile = new OpenReassignCallback( $callBackFile );
                $this->_aOpenReassignCallback[] = $callBackFile;
            }
        } catch(Excepton $e) {
            throw $e;
        }
    }

    /**
     * Return all callBackFiles registered
     *
     * @return array
     */
    public function getOpenReassignCallback()
    {
        return $this->_aOpenReassignCallback;
    }

    public function getPluginsData()
    {
        return $this->_aPlugins;
    }

    /**
     * The following function method extracts the plugin if exists one
     * with the same uppercase characters, this is required for the
     *
     * @param $code
     */
    public function getPluginByCode($code)
    {
        $plugin = false;
        foreach ($this->_aPlugins as $plugin) {
            $plugin = (array)$plugin;
            if (strtoupper($plugin['sNamespace']) == $code) {
                return (object)$plugin;
            }
        }
        return $plugin;
    }

    /**
     * Checks if the plugin name is Enterprise Plugin
     *
     * @param string $pluginName Plugin name
     * @param string $path       Path to plugin
     *
     * @return bool Returns TRUE when plugin name is Enterprise Plugin, FALSE otherwise
     */
    public function isEnterprisePlugin($pluginName, $path = null)
    {
        $path = (!is_null($path) && $path != '') ? rtrim($path, '/\\') . PATH_SEP : PATH_PLUGINS;
        $pluginFile = $pluginName . '.php';

        //Return
        return preg_match(
            '/^.*class\s+' . $pluginName . 'Plugin\s+extends\s+(?:enterprisePlugin)\s*\{.*$/i',
            str_replace(["\n", "\r", "\t"], ' ', file_get_contents($path . $pluginFile))
        );
    }

    /**
     * Registry in an array routes for js or css files.
     * @param type $pluginName
     * @param type $pathFile
     * @throws Exception
     */
    public function registerDesignerSourcePath($pluginName, $pathFile)
    {
        try {
            $flagFound = false;

            foreach ($this->_arrayDesignerSourcePath as $value) {
                if ($value->pluginName == $pluginName && $value->pathFile == $pathFile) {
                    $flagFound = true;
                    break;
                }
            }

            if (!$flagFound) {
                $obj = new stdClass();
                $obj->pluginName = $pluginName;
                $obj->pathFile = $pathFile;

                $this->_arrayDesignerSourcePath[] = $obj;
            }
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * You obtain an array containing the routes recorded by the
     * function registerDesignerSourcePath.
     * @return type
     * @throws Exception
     */
    public function getDesignerSourcePath()
    {
        try {
            return $this->_arrayDesignerSourcePath;
        } catch (Exception $e) {
            throw $e;
        }
    }

    /**
     * Saves the state of instance, in the private property 'stateSaved'.
     * Use the 'restoreState()' method to put the instance in the saved state.
     */
    public static function saveState()
    {
        $pluginRegistry = PMPluginRegistry::getSingleton();
        self::$stateSaved = $pluginRegistry->serializeInstance();
    }

    /**
     * Restores the state of the instance that is in the private variable 'stateSaved'.
     * You must save the state of the instacia with the method 'saveState()'
     * before being called.
     */
    public static function restoreState()
    {
        if (self::$stateSaved !== null) {
            $pluginRegistry = PMPluginRegistry::getSingleton();
            self::$instance = $pluginRegistry->unSerializeInstance(self::$stateSaved);
            self::$stateSaved = null;
        }
    }

    /**
     * Get all variables of object
     * @return array
     */
    public function iterateVisible()
    {
        $response = array();
        foreach ($this as $key => $value) {
            $response[$key] = $value;
        }
        return $response;
    }
}