1388 lines
43 KiB
PHP
Executable File
1388 lines
43 KiB
PHP
Executable File
<?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 );
|
|
}
|
|
}
|