\n \n";
$plug = new Plugin();
$pluglist = $plug->find([], "name, directory");
foreach ($pluglist as $plugin) {
$msg = substr(str_pad($plugin['directory'], 30), 0, 20).
" Name: ".Toolbox::substr(str_pad($plugin['name'], 40), 0, 30).
" Version: ".str_pad($plugin['version'], 10).
" State: ";
$state = $plug->isLoadable($plugin['directory']) ? $plugin['state'] : self::TOBECLEANED;
$msg .= self::getState($state);
echo wordwrap("\t".$msg."\n", $width, "\n\t\t");
}
echo "\n |
";
}
/**
* Define a new class managed by a plugin
*
* @param string $itemtype Class name
* @param array $attrib Array of attributes, a hashtable with index in
* (classname, typename, reservation_types)
*
* @return bool
**/
static function registerClass($itemtype, $attrib = []) {
global $CFG_GLPI;
$plug = isPluginItemType($itemtype);
if (!$plug) {
return false;
}
$all_types = preg_grep('/.+_types/', array_keys($CFG_GLPI));
$all_types[] = 'networkport_instantiations';
$mapping = [
'doc_types' => 'document_types',
'helpdesk_types' => 'ticket_types',
'netport_types' => 'networkport_types'
];
foreach ($mapping as $orig => $fixed) {
if (isset($attrib[$orig])) {
\Toolbox::deprecated(
sprintf(
'%1$s type is deprecated, use %2$s instead.',
$orig,
$fixed
)
);
$attrib[$fixed] = $attrib[$orig];
unset($attrib[$orig]);
}
}
$blacklist = ['device_types'];
foreach ($all_types as $att) {
if (!in_array($att, $blacklist) && isset($attrib[$att]) && $attrib[$att]) {
$CFG_GLPI[$att][] = $itemtype;
unset($attrib[$att]);
}
}
if (isset($attrib['device_types']) && $attrib['device_types']
&& method_exists($itemtype, 'getItem_DeviceType')) {
if (class_exists($itemtype::getItem_DeviceType())) {
$CFG_GLPI['device_types'][] = $itemtype;
}
unset($attrib[$att]);
}
if (isset($attrib['addtabon'])) {
if (!is_array($attrib['addtabon'])) {
$attrib['addtabon'] = [$attrib['addtabon']];
}
foreach ($attrib['addtabon'] as $form) {
CommonGLPI::registerStandardTab($form, $itemtype);
}
}
//Manage entity forward from a source itemtype to this itemtype
if (isset($attrib['forwardentityfrom'])) {
CommonDBTM::addForwardEntity($attrib['forwardentityfrom'], $itemtype);
}
return true;
}
/**
* This function executes a hook.
*
* @param string $name Name of hook to fire
* @param mixed $param Parameters if needed : if object limit to the itemtype (default NULL)
*
* @return mixed $data
**/
static function doHook($name, $param = null) {
global $PLUGIN_HOOKS;
if ($param == null) {
$data = func_get_args();
} else {
$data = $param;
}
// Apply hook only for the item
if (($param != null) && is_object($param)) {
$itemtype = get_class($param);
if (isset($PLUGIN_HOOKS[$name]) && is_array($PLUGIN_HOOKS[$name])) {
foreach ($PLUGIN_HOOKS[$name] as $plugin_key => $tab) {
if (!Plugin::isPluginActive($plugin_key)) {
continue;
}
if (isset($tab[$itemtype])) {
self::includeHook($plugin_key);
if (is_callable($tab[$itemtype])) {
call_user_func($tab[$itemtype], $data);
}
}
}
}
} else { // Standard hook call
if (isset($PLUGIN_HOOKS[$name]) && is_array($PLUGIN_HOOKS[$name])) {
foreach ($PLUGIN_HOOKS[$name] as $plugin_key => $function) {
if (!Plugin::isPluginActive($plugin_key)) {
continue;
}
self::includeHook($plugin_key);
if (is_callable($function)) {
call_user_func($function, $data);
}
}
}
}
/* Variable-length argument lists have a slight problem when */
/* passing values by reference. Pity. This is a workaround. */
return $data;
}
/**
* This function executes a hook.
*
* @param string $name Name of hook to fire
* @param mixed $parm Parameters (default NULL)
*
* @return mixed $data
**/
static function doHookFunction($name, $parm = null) {
global $PLUGIN_HOOKS;
$ret = $parm;
if (isset($PLUGIN_HOOKS[$name]) && is_array($PLUGIN_HOOKS[$name])) {
foreach ($PLUGIN_HOOKS[$name] as $plugin_key => $function) {
if (!Plugin::isPluginActive($plugin_key)) {
continue;
}
self::includeHook($plugin_key);
if (is_callable($function)) {
$ret = call_user_func($function, $ret);
}
}
}
/* Variable-length argument lists have a slight problem when */
/* passing values by reference. Pity. This is a workaround. */
return $ret;
}
/**
* This function executes a hook for 1 plugin.
*
* @param string $plugin_key System name of the plugin
* @param string|callable $hook suffix used to build function to be called ("plugin_myplugin_{$hook}")
* or callable function
* @param mixed ...$args [optional] One or more arguments passed to hook function
*
* @return mixed $data
**/
static function doOneHook($plugin_key, $hook, ...$args) {
$plugin_key = strtolower($plugin_key);
if (!Plugin::isPluginActive($plugin_key)) {
return;
}
self::includeHook($plugin_key);
if (is_string($hook) && !is_callable($hook)) {
$hook = "plugin_" . $plugin_key . "_" . $hook;
}
if (is_callable($hook)) {
return call_user_func_array($hook, $args);
}
}
/**
* Get dropdowns for plugins
*
* @return array Array containing plugin dropdowns
**/
static function getDropdowns() {
$dps = [];
foreach (self::getPlugins() as $plug) {
$tab = self::doOneHook($plug, 'getDropdown');
if (is_array($tab)) {
$dps = array_merge($dps, [self::getInfo($plug, 'name') => $tab]);
}
}
return $dps;
}
/**
* Get information from a plugin
*
* @param string $plugin System name (Plugin directory)
* @param string $info Wanted info (name, version, ...), NULL for all
*
* @since 0.84
*
* @return string|array The specific information value requested or an array of all information if $info is null.
**/
static function getInfo($plugin, $info = null) {
$fct = 'plugin_version_'.strtolower($plugin);
if (function_exists($fct)) {
$res = $fct();
if (!isset($res['requirements']) && isset($res['minGlpiVersion'])) {
$res['requirements'] = ['glpi' => ['min' => $res['minGlpiVersion']]];
}
} else {
Toolbox::logError("$fct method must be defined!");
$res = [];
}
if (isset($info)) {
return (isset($res[$info]) ? $res[$info] : '');
}
return $res;
}
/**
* Returns plugin information from directory.
*
* @param string $directory
*
* @return array
*/
public function getInformationsFromDirectory($directory) {
$informations = [];
foreach (PLUGINS_DIRECTORIES as $base_dir) {
if (!is_dir($base_dir)) {
continue;
}
$setup_file = "$base_dir/$directory/setup.php";
if (file_exists($setup_file)) {
// Includes are made inside a function to prevent included files to override
// variables used in this function.
// For example, if the included files contains a $plugin variable, it will
// replace the $plugin variable used here.
$include_fct = function () use ($directory, $setup_file) {
self::loadLang($directory);
include_once($setup_file);
};
$include_fct();
$informations = Toolbox::addslashes_deep(self::getInfo($directory));
// plugin found, don't parse others directories
break;
}
}
return $informations;
}
/**
* Get database relations for plugins
*
* @return array Array containing plugin database relations
**/
static function getDatabaseRelations() {
$dps = [];
foreach (self::getPlugins() as $plugin_key) {
self::includeHook($plugin_key);
$function2 = "plugin_".$plugin_key."_getDatabaseRelations";
if (function_exists($function2)) {
$dps = array_merge_recursive($dps, $function2());
}
}
return $dps;
}
/**
* Get additional search options managed by plugins
*
* @param $itemtype
*
* @return array Array containing plugin search options for given type
**/
static function getAddSearchOptions($itemtype) {
$sopt = [];
foreach (self::getPlugins() as $plugin_key) {
self::includeHook($plugin_key);
$function = "plugin_".$plugin_key."_getAddSearchOptions";
if (function_exists($function)) {
$tmp = $function($itemtype);
if (is_array($tmp) && count($tmp)) {
$sopt += $tmp;
}
}
}
return $sopt;
}
/**
* Include the hook file for a plugin
*
* @param string $plugin_key
*/
static function includeHook(string $plugin_key = "") {
foreach (PLUGINS_DIRECTORIES as $base_dir) {
if (file_exists("$base_dir/$plugin_key/hook.php")) {
include_once("$base_dir/$plugin_key/hook.php");
break;
}
}
}
/**
* Get additional search options managed by plugins
*
* @since 9.2
*
* @param string $itemtype Item type
*
* @return array An *indexed* array of search options
*
* @see https://glpi-developer-documentation.rtfd.io/en/master/devapi/search.html
**/
static function getAddSearchOptionsNew($itemtype) {
$options = [];
foreach (self::getPlugins() as $plugin_key) {
self::includeHook($plugin_key);
$function = "plugin_".$plugin_key."_getAddSearchOptionsNew";
if (function_exists($function)) {
$tmp = $function($itemtype);
foreach ($tmp as $opt) {
if (!isset($opt['id'])) {
throw new \Exception($itemtype . ': invalid search option! ' . print_r($opt, true));
}
$optid = $opt['id'];
unset($opt['id']);
if (isset($options[$optid])) {
$message = "Duplicate key $optid ({$options[$optid]['name']}/{$opt['name']}) in ".
$itemtype . " searchOptions!";
Toolbox::logError($message);
}
foreach ($opt as $k => $v) {
$options[$optid][$k] = $v;
}
}
}
}
return $options;
}
/**
* Check if there is a plugin enabled that supports importing items
*
* @return boolean
*
* @since 0.84
**/
static function haveImport() {
global $PLUGIN_HOOKS;
return (isset($PLUGIN_HOOKS['import_item']) && count($PLUGIN_HOOKS['import_item']));
}
/**
* Get an internationalized message for incompatible plugins (either core or php version)
*
* @param string $type Either 'php' or 'core', defaults to 'core'
* @param string $min Minimal required version
* @param string $max Maximal required version
*
* @since 9.2
*
* @return string
*/
static public function messageIncompatible($type = 'core', $min = null, $max = null) {
$type = ($type === 'core' ? __('GLPI') : __('PHP'));
if ($min === null && $max !== null) {
return sprintf(
__('This plugin requires %1$s < %2$s.'),
$type,
$max
);
} else if ($min !== null && $max === null) {
return sprintf(
__('This plugin requires %1$s >= %2$s.'),
$type,
$min
);
} else {
return sprintf(
__('This plugin requires %1$s >= %2$s and < %3$s.'),
$type,
$min,
$max
);
}
}
/**
* Get an internationalized message for missing requirement (extension, other plugin, ...)
*
* @param string $type Type of what is missing, one of:
* - ext (PHP module)
* - plugin (other plugin)
* - compil (compilation option)
* - param (GLPI configuration parameter)
* @param string $name Missing name
*
* @since 9.2
*
* @return string
*/
static public function messageMissingRequirement($type, $name) {
switch ($type) {
case 'ext':
return sprintf(
__('This plugin requires PHP extension %1$s'),
$name
);
break;
case 'plugin':
return sprintf(
__('This plugin requires %1$s plugin'),
$name
);
break;
case 'compil':
return sprintf(
__('This plugin requires PHP compiled along with "%1$s"'),
$name
);
break;
case 'param':
return sprintf(
__('This plugin requires PHP parameter %1$s'),
$name
);
break;
case 'glpiparam':
return sprintf(
__('This plugin requires GLPI parameter %1$s'),
$name
);
break;
default:
throw new \RuntimeException("messageMissing type $type is unknown!");
}
}
/**
* Check declared versions (GLPI, PHP, ...)
*
* @since 9.2
*
* @param string $name System name (Plugin directory)
*
* @return boolean
*/
public function checkVersions($name) {
$infos = self::getInfo($name);
$ret = true;
if (isset($infos['requirements'])) {
if (isset($infos['requirements']['glpi'])) {
$glpi = $infos['requirements']['glpi'];
if (isset($glpi['min']) || isset($glpi['max'])) {
$ret = $ret && $this->checkGlpiVersion($infos['requirements']['glpi']);
}
if (isset($glpi['params'])) {
$ret = $ret && $this->checkGlpiParameters($glpi['params']);
}
if (isset($glpi['plugins'])) {
$ret = $ret && $this->checkGlpiPlugins($glpi['plugins']);
}
}
if (isset($infos['requirements']['php'])) {
$php = $infos['requirements']['php'];
if (isset($php['min']) || isset($php['max'])) {
$ret = $ret && $this->checkPhpVersion($php);
}
if (isset($php['exts'])) {
$ret = $ret && $this->checkPhpExtensions($php['exts']);
}
if (isset($php['params'])) {
$ret = $ret && $this->checkPhpParameters($php['params']);
}
}
}
return $ret;
}
/**
* Check for GLPI version
*
* @since 9.2
* @since 9.3 Removed the 'dev' key of $info parameter.
*
* @param array $infos Requirements infos:
* - min: minimal supported version,
* - max: maximal supported version
* One of min or max is required.
*
* @return boolean
*/
public function checkGlpiVersion($infos) {
if (!isset($infos['min']) && !isset($infos['max'])) {
throw new LogicException('Either "min" or "max" is required for GLPI requirements!');
}
$glpiVersion = $this->isGlpiPrever() ? $this->getGlpiPrever() : $this->getGlpiVersion();
$compat = true;
if (isset($infos['min']) && !version_compare($glpiVersion, $infos['min'], '>=')) {
$compat = false;
}
if (isset($infos['max']) && !version_compare($glpiVersion, $infos['max'], '<')) {
$compat = false;
}
if (!$compat) {
echo Plugin::messageIncompatible(
'core',
(isset($infos['min']) ? $infos['min'] : null),
(isset($infos['max']) ? $infos['max'] : null)
);
}
return $compat;
}
/**
* Check for PHP version
*
* @since 9.2
*
* @param array $infos Requirements infos:
* - min: minimal supported version,
* - max: maximal supported version.
* One of min or max is required.
*
* @return boolean
*/
public function checkPhpVersion($infos) {
$compat = true;
if (isset($infos['min']) && isset($infos['max'])) {
$compat = !(version_compare($this->getPhpVersion(), $infos['min'], 'lt') || version_compare($this->getPhpVersion(), $infos['max'], 'ge'));
} else if (isset($infos['min'])) {
$compat = !(version_compare($this->getPhpVersion(), $infos['min'], 'lt'));
} else if (isset($infos['max'])) {
$compat = !(version_compare($this->getPhpVersion(), $infos['max'], 'ge'));
} else {
throw new LogicException('Either "min" or "max" is required for PHP requirements!');
}
if (!$compat) {
echo Plugin::messageIncompatible(
'php',
(isset($infos['min']) ? $infos['min'] : null),
(isset($infos['max']) ? $infos['max'] : null)
);
}
return $compat;
}
/**
* Check fo required PHP extensions
*
* @since 9.2
*
* @param array $exts Extensions lists/config @see Config::checkExtensions()
*
* @return boolean
*/
public function checkPhpExtensions($exts) {
$report = Config::checkExtensions($exts);
if (count($report['missing'])) {
foreach (array_keys($report['missing']) as $ext) {
echo self::messageMissingRequirement('ext', $ext) . '