luos/workflow/engine/classes/class.pluginRegistry.php

<?php

/**
 * class.pluginRegistry.php
 *
 * @package workflow.engine.classes
 *
 * ProcessMaker Open Source Edition
 * Copyright (C) 2004 - 2011 Colosa Inc.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * For more information, contact Colosa Inc, 2566 Le Jeune Rd.,
 * Coral Gables, FL, 33134, USA, or email info@colosa.com.
 */

/**
 *
 * @package workflow.engine.classes
 */

class pluginDetail
{
    var $sNamespace;
    var $sClassName;
    var $sFriendlyName = null;
    var $sDescription = null;
    var $sSetupPage = null;
    var $sFilename;
    var $sPluginFolder = '';
    var $sCompanyLogo = '';
    var $iVersion = 0;
    var $enabled = false;
    var $aWorkspaces = null;
    var $bPrivate = false;

    /**
     * This function is the constructor of the pluginDetail class
     *
     * @param string $sNamespace
     * @param string $sClassName
     * @param string $sFilename
     * @param string $sFriendlyName
     * @param string $sPluginFolder
     * @param string $sDescription
     * @param string $sSetupPage
     * @param integer $iVersion
     * @return void
     */
    function __construct ($sNamespace, $sClassName, $sFilename, $sFriendlyName = '', $sPluginFolder = '', $sDescription = '', $sSetupPage = '', $iVersion = 0)
    {
        $this->sNamespace = $sNamespace;
        $this->sClassName = $sClassName;
        $this->sFriendlyName = $sFriendlyName;
        $this->sDescription = $sDescription;
        $this->sSetupPage = $sSetupPage;
        $this->iVersion = $iVersion;
        $this->sFilename = $sFilename;
        if ($sPluginFolder == '')
            $this->sPluginFolder = $sNamespace;
        else
            $this->sPluginFolder = $sPluginFolder;
    }
}

/**
 *
 * @package workflow.engine.classes
 */

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 ();

    /**
     * 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 static $instance = 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
     */
    function &getSingleton ()
    {
        if (self::$instance == NULL) {
            self::$instance = new PMPluginRegistry();
        }
        return self::$instance;
    }

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

    /**
     * This function takes a single serialized variable and converts it back a code
     *
     * @param string $serialized
     * @return void
     */
    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
     */
    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
     */
    function registerPlugin ($sNamespace, $sFilename = null)
    {
        $sClassName = $sNamespace . 'plugin';
        if (isset( $this->_aPluginDetails[$sNamespace] ))
            return;
            //require_once ( $sFilename );
        $plugin = new $sClassName( $sNamespace, $sFilename );
        $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
     */
    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
     */
    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;
                $oPlugin = new $detail->sClassName( $detail->sNamespace, $detail->sFilename );
                $this->_aPlugins[$detail->sNamespace] = $oPlugin;
                if (method_exists( $oPlugin, 'enable' )) {
                    $oPlugin->enable();
                }
                return true;
            }
        }
        throw new Exception( "Unable to enable plugin '$sNamespace' (plugin not found)" );
    }

    /**
     * disable the plugin in the singleton
     *
     * @param unknown_type $sNamespace
     */
    function disablePlugin ($sNamespace, $eventPlugin = 1)
    {
        $sw = false;

        foreach ($this->_aPluginDetails as $namespace => $detail) {
            if ($namespace == $sNamespace) {
                unset( $this->_aPluginDetails[$sNamespace] );

                if ($eventPlugin == 1) {
                    $plugin = new $detail->sClassName( $detail->sNamespace, $detail->sFilename );
                    $this->_aPlugins[$detail->sNamespace] = $plugin;
                    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] );
        }

        //unregistering javascripts from this plugin
        $this->unregisterJavascripts( $sNamespace );
        //unregistering rest services from this plugin
        $this->unregisterRestService( $sNamespace );
    }

    /**
     * get status plugin in the singleton
     *
     * @param unknown_type $sNamespace
     */
    function getStatusPlugin ($sNamespace)
    {
        foreach ($this->_aPluginDetails as $namespace => $detail) {
            if ($sNamespace == $namespace)
                if ($this->_aPluginDetails[$sNamespace]->enabled)
                    return 'enabled';
                else
                    return 'disabled';
        }
        return 0;
    }

    /**
     * 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
     */
    function installPluginArchive ($filename, $pluginName)
    {
        G::LoadThirdParty( "pear/Archive", "Tar" );
        $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" ));
        }

        require_once (PATH_PLUGINS . $pluginFile);
        $details = $this->getPluginDetails( $pluginFile );

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

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

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

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

        ///////
        require_once (PATH_PLUGINS . $pluginFile);

        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;
            }
        }
    }

    function uninstallPluginWorkspaces ($arrayPlugin)
    {
        G::LoadClass( "system" );
        G::LoadClass( "wsTools" );

        $workspace = System::listWorkspaces();

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

            if (file_exists( $wsPathDataSite . "plugin.singleton" )) {
                //G::LoadClass("plugin");
                //Here we are loading all plug-ins registered
                //The singleton has a list of enabled plug-ins


                $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
     */
    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
     */
    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
     */
    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
     */
    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
     */
    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
     */
    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;
                    }
                } else if (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;
        } else if (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
     */
    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
     */
    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
     */
    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
     */
    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
     */
    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
     */
    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
     */
    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
     */
    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
     */
    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
     */
    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
     */
    function getDashlets ()
    {
        return $this->_aDashlets;
    }

    /**
     * this function returns all reports registered
     *
     * @return array
     */
    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
     */
    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
     */
    function getSteps ()
    {
        return $this->_aSteps;
    }

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

    /**
     * execute all triggers related to a triggerId
     *
     * @param unknown_type $menuId
     * @return object
     */
    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 = 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
     */
    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 = 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
     */
    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
     */
    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
     */
    function &getPlugin ($sNamespace)
    {
        if (array_key_exists( $sNamespace, $this->_aPlugins )) {
            return $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;
     */
    }

    /**
     * set company logo
     *
     * @param unknown_type $sNamespace
     * @param unknown_type $filename
     * @return void
     */
    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
     */
    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
     */
    function setupPlugins ()
    {
        try {
            $iPlugins = 0;
            G::LoadClass( 'serverConfiguration' );
            $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 )) {
                        if (strpos( $detail->sFilename, PATH_SEP ) !== false) {
                            $aux = explode( PATH_SEP, $detail->sFilename );
                        } else {
                            $aux = explode( chr( 92 ), $detail->sFilename );
                        }
                        $sFilename = PATH_PLUGINS . $aux[count( $aux ) - 1];
                        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
     */
    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
     */
    function getFieldsForPageSetup ($sNamespace)
    {
        $oData = NULL;
        return $this->executeMethod( $sNamespace, 'getFieldsForPageSetup', $oData );
    }

    /**
     * this function updates Fields For Page on Setup
     *
     * @param string $sNamespace
     * @return void
     */
    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 );
    }

    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
     */
    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)
     */
    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
     */
    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
     */
    function getCaseSchedulerPlugins ()
    {
        return $this->_aCaseSchedulerPlugin;
    }

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

    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
     */
    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, $classname, $path = '')
    {
        $restService = new StdClass();
        $restService->sNamespace = $sNamespace;
        $restService->classname = $classname;

        if (empty( $path )) {
            $path = PATH_PLUGINS . $restService->sNamespace . "/services/rest/$classname.php";

            if (! file_exists( $path )) {
                $path = PATH_PLUGINS . $restService->sNamespace . "/services/rest/crud/$classname.php";
            }
        }

        if (! file_exists( $path )) {
            return false;
        }

        $restService->path = $path;
        $this->_restServices[] = $restService;

        return true;
    }

    /**
     * Unregister a rest service class of a plugin
     *
     * @param string $sNamespace The namespace for the plugin
     */
    public function unregisterRestService ($sNamespace)
    {
        foreach ($this->_restServices as $i => $service) {
            if ($sNamespace == $service->sNamespace) {
                unset( $this->_restServices[$i] );
            }
        }

        // Re-index when all js were unregistered
        $this->_restServices = array_values( $this->_restServices );
    }

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

    public function getRegisteredRestClassFiles ()
    {
        $restClassFiles = array ();

        foreach ($this->_restServices as $restService) {
            $restClassFiles[] = $restService->path;
        }

        return $restClassFiles;
    }

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

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

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

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