%PDF-
%PDF-
Mini Shell
Mini Shell
<?php
/**
* FusionInventory
*
* Copyright (C) 2010-2023 by the FusionInventory Development Team.
*
* http://www.fusioninventory.org/
* https://github.com/fusioninventory/fusioninventory-for-glpi
* http://forge.fusioninventory.org/
*
* ------------------------------------------------------------------------
*
* LICENSE
*
* This file is part of FusionInventory project.
*
* FusionInventory 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.
*
* FusionInventory 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 FusionInventory. If not, see <http://www.gnu.org/licenses/>.
*
* ------------------------------------------------------------------------
*
* This file is used to manage the deploy groups.
*
* ------------------------------------------------------------------------
*
* @package FusionInventory
* @author Alexandre Delaunay
* @author David Durieux
* @copyright Copyright (c) 2010-2023 FusionInventory team
* @license AGPL License 3.0 or (at your option) any later version
* http://www.gnu.org/licenses/agpl-3.0-standalone.html
* @link http://www.fusioninventory.org/
* @link https://github.com/fusioninventory/fusioninventory-for-glpi
*
*/
if (!defined('GLPI_ROOT')) {
die("Sorry. You can't access directly to this file");
}
/**
* Manage the deploy groups.
*/
class PluginFusioninventoryDeployGroup extends CommonDBTM {
/**
* Define constant name of static group
*
* @var string
*/
const STATIC_GROUP = 'STATIC';
/**
* Define constant name of dynamic group
*
* @var string
*/
const DYNAMIC_GROUP = 'DYNAMIC';
/**
* The right name for this class
*
* @var string
*/
static $rightname = "plugin_fusioninventory_group";
/**
* Define the array of itemtype allowed in static groups
*
* @var type
*/
protected $static_group_types = ['Computer'];
/**
* We activate the history.
*
* @var boolean
*/
public $dohistory = true;
public $grouptypes = [];
/**
* __contruct function used to define the 2 types of groups
*/
public function __construct() {
$this->grouptypes = [
self::STATIC_GROUP => __('Static group', 'fusioninventory'),
self::DYNAMIC_GROUP => __('Dynamic group', 'fusioninventory')
];
}
/**
* Get name of this type by language of the user connected
*
* @param integer $nb number of elements
* @return string name of this type
*/
static function getTypeName($nb = 0) {
return __('FusionInventory group', 'fusioninventory');
}
/**
* Define tabs to display on form page
*
* @param array $options
* @return array containing the tabs name
*/
function defineTabs($options = []) {
$ong = [];
$this->addDefaultFormTab($ong);
$count = self::getMatchingItemsCount("PluginFusionInventoryTaskjob");
$ong[$this->getType().'$task'] = self::createTabEntry(_n('Associated task', 'Associated tasks', $count), $count);
$this->addStandardTab('Log', $ong, $options);
return $ong;
}
function getMatchingItemsCount($itemtype) {
$count = 0;
if ($itemtype == 'PluginFusionInventoryTaskjob'
&& is_numeric($_GET['id'])) {
$pfTaskjob = new PluginFusioninventoryTaskjob();
$data = $pfTaskjob->find(['actors' => ['LIKE', '%"PluginFusioninventoryDeployGroup":"'.$_GET['id'].'"%']]);
$count = count($data);
}
return $count;
}
/**
* Display the content of the tab
*
* @param object $item
* @param integer $tabnum number of the tab to display
* @param integer $withtemplate 1 if is a template form
* @return boolean
*/
static function displayTabContentForItem(CommonGLPI $item, $tabnum = 1, $withtemplate = 0) {
global $DB;
if ($tabnum == 'task') {
echo "<table width='950' class='tab_cadre_fixe'>";
echo "<tr>";
echo "<th>";
echo __('Task');
echo "</th>";
echo "<th>";
echo __('Active');
echo "</th>";
echo "<th>";
echo __('Module method');
echo "</th>";
echo "</tr>";
$modules_methods = PluginFusioninventoryStaticmisc::getModulesMethods();
$link = Toolbox::getItemTypeFormURL("PluginFusioninventoryTask");
$query = "SELECT
glpi_plugin_fusioninventory_tasks.id as id,
glpi_plugin_fusioninventory_tasks.name as tname,
glpi_plugin_fusioninventory_tasks.is_active,
glpi_plugin_fusioninventory_taskjobs.method
FROM glpi_plugin_fusioninventory_taskjobs
LEFT JOIN glpi_plugin_fusioninventory_tasks on plugin_fusioninventory_tasks_id=glpi_plugin_fusioninventory_tasks.id
WHERE `actors` LIKE '%\"PluginFusioninventoryDeployGroup\":\"".$_GET['id']."\"%'
ORDER BY glpi_plugin_fusioninventory_tasks.name";
$res = $DB->query($query);
while ($row = $DB->fetchAssoc($res)) {
echo "<tr class='tab_bg_1'>";
echo "<td>";
echo "<a href='".$link."?id=".$row['id']."'>".$row['tname']."</a>";
echo "</td>";
echo "<td>";
echo Dropdown::getYesNo($row['is_active']);
echo "</td>";
echo "<td>";
echo $modules_methods[$row['method']];
echo "</td>";
echo "</tr>";
}
echo "</table>";
return true;
}
return false;
}
/**
* Get the massive actions for this object
*
* @param object|null $checkitem
* @return array list of actions
*/
function getSpecificMassiveActions($checkitem = null) {
$actions = [];
$actions[__CLASS__.MassiveAction::CLASS_ACTION_SEPARATOR.'targettask'] = __('Target a task', 'fusioninventory');
$actions[__CLASS__.MassiveAction::CLASS_ACTION_SEPARATOR.'duplicate'] = _sx('button', 'Duplicate');
return $actions;
}
/**
* Display form related to the massive action selected
*
* @param object $ma MassiveAction instance
* @return boolean
*/
static function showMassiveActionsSubForm(MassiveAction $ma) {
switch ($ma->getAction()) {
case 'add_to_static_group':
Dropdown::show('PluginFusioninventoryDeployGroup',
['condition' => ['type' => PluginFusioninventoryDeployGroup::STATIC_GROUP]]);
echo Html::submit(_x('button', 'Post'), ['name' => 'massiveaction']);
return true;
case 'duplicate':
echo Html::submit(_x('button', 'Post'), ['name' => 'massiveaction']);
return true;
}
return parent::showMassiveActionsSubForm($ma);
}
/**
* Execution code for massive action
*
* @param object $ma MassiveAction instance
* @param object $item item on which execute the code
* @param array $ids list of ID on which execute the code
*/
static function processMassiveActionsForOneItemtype(MassiveAction $ma, CommonDBTM $item,
array $ids) {
switch ($ma->getAction()) {
case 'add_to_static_group' :
if ($item->getType() == 'Computer') {
$group_item = new PluginFusioninventoryDeployGroup_Staticdata();
foreach ($ids as $id) {
if (!countElementsInTable($group_item->getTable(),
[
'plugin_fusioninventory_deploygroups_id' => $_POST['plugin_fusioninventory_deploygroups_id'],
'itemtype' => 'Computer',
'items_id' => $id,
])) {
$values = [
'plugin_fusioninventory_deploygroups_id' => $_POST['plugin_fusioninventory_deploygroups_id'],
'itemtype' => 'Computer',
'items_id' => $id];
$group_item->add($values);
$ma->itemDone($item->getType(), $id, MassiveAction::ACTION_OK);
} else {
$ma->itemDone($item->getType(), $id, MassiveAction::ACTION_KO);
}
}
}
break;
case 'duplicate':
$pfGroup = new self();
foreach ($ids as $key) {
if ($pfGroup->getFromDB($key)) {
if ($pfGroup->duplicate($pfGroup->getID())) {
//set action massive ok for this item
$ma->itemDone($item->getType(), $key, MassiveAction::ACTION_OK);
} else {
// KO
$ma->itemDone($item->getType(), $key, MassiveAction::ACTION_KO);
}
}
}
break;
default:
parent::processMassiveActionsForOneItemtype($ma, $item, $ids);
break;
}
}
function duplicate($deploygroups_id) {
$result = true;
if ($this->getFromDB($deploygroups_id)) {
$input = $this->fields;
unset($input['id']);
$input['name'] = sprintf(__('Copy of %s'), $this->fields['name']);
$new_deploygroups_id = $this->add($input);
if ($new_deploygroups_id) {
if ($this->fields['type'] == self::STATIC_GROUP) {
$result
= PluginFusioninventoryDeployGroup_Staticdata::duplicate($deploygroups_id, $new_deploygroups_id);
} else {
$result
= PluginFusioninventoryDeployGroup_Dynamicdata::duplicate($deploygroups_id, $new_deploygroups_id);
}
} else {
$result = false;
}
} else {
$result = false;
}
return $result;
}
/**
* Display title of the page
*
* @global array $CFG_GLPI
*/
function title() {
global $CFG_GLPI;
$buttons = [];
$title = self::getTypeName();
if ($this->canCreate()) {
$buttons["group.form.php?new=1"] = __('Add group', 'fusioninventory');
$title = "";
}
Html::displayTitle($CFG_GLPI['root_doc']."/plugins/fusinvdeploy/pics/menu_group.png",
$title, $title, $buttons);
}
/**
* Display form
*
* @param integer $ID
* @param array $options
* @return true
*/
function showForm($ID, $options = []) {
$this->initForm($ID, $options);
$this->showFormHeader($options);
echo "<tr class='tab_bg_1'>";
echo "<td>".__('Name')." :</td>";
echo "<td align='center'>";
echo Html::input('name', ['size' => 40, 'value' => $this->fields['name']]);
echo "</td>";
echo "<td rowspan='2'>".__('Comments')." :</td>";
echo "<td rowspan='2' align='center'>";
echo "<textarea cols='40' rows='6' name='comment' >".$this->fields["comment"]."</textarea>";
echo "</td>";
echo "</tr>";
echo "<tr class='tab_bg_1'>";
echo "<td>".__('Type')." :</td>";
echo "<td align='center'>";
self::dropdownGroupType('type', $this->fields['type']);
echo "</td>";
echo "</tr>";
$this->showFormButtons($options);
return true;
}
/**
* Get search function for the class
*
* @return array
*/
function rawSearchOptions() {
$tab = [];
$tab[] = [
'id' => 'common',
'name' => self::getTypeName(),
];
$tab[] = [
'id' => '1',
'table' => $this->getTable(),
'field' => 'name',
'name' => __('Name'),
'datatype' => 'itemlink',
'massiveaction' => false,
'autocomplete' => true,
];
$tab[] = [
'id' => '2',
'table' => $this->getTable(),
'field' => 'type',
'name' => __('Type'),
'datatype' => 'specific',
'massiveaction' => false,
'searchtype' => 'equals',
];
return $tab;
}
/**
* Check if this group is a dynamic group or not
*
* @return boolean
*/
function isDynamicGroup() {
return ($this->fields['type'] == self::DYNAMIC_GROUP);
}
/**
* Check if this group is a static group or not
*
* @return boolean
*/
function isStaticGroup() {
return ($this->fields['type'] == self::STATIC_GROUP);
}
/**
* Get a specific value to display
*
* @param string $field
* @param array $values
* @param array $options
* @return string
*/
static function getSpecificValueToDisplay($field, $values, array $options = []) {
$group = new self();
if (!is_array($values)) {
$values = [$field => $values];
}
if ($field == 'type') {
return $group->grouptypes[$values[$field]];
}
return '';
}
/**
* Display dropdown to select dynamic of static group
*
* @param string $name
* @param string $value
* @return string
*/
static function dropdownGroupType($name = 'type', $value = 'STATIC') {
$group = new self();
if ($name == 'type') {
return Dropdown::showFromArray($name, $group->grouptypes,
['value'=>$value, 'display'=>true]);
} else {
return Dropdown::showFromArray($name, $group->grouptypes,
['value'=>$value, 'display'=>false]);
}
}
/**
* Get specific value to select
*
* @param string $field
* @param string $name
* @param string|array $values
* @param array $options
* @return string
*/
static function getSpecificValueToSelect($field, $name = '', $values = '', array $options = []) {
if (!is_array($values)) {
$values = [$field => $values];
}
$options['display'] = false;
if ($field == 'type') {
return self::dropdownGroupType($name, $values[$field]);
}
return parent::getSpecificValueToSelect($field, $name, $values, $options);
}
/**
* Get the URL to pass to the search engine
* @since 9.2
*
* @param integer $deploygroup_id the ID of the group
* @param boolean $is_dynamic is the group dynamic or static
* @return string the target
*/
static function getSearchEngineTargetURL($deploygroup_id, $is_dynamic = false) {
$target = PluginFusioninventoryDeployGroup::getFormURLWithID($deploygroup_id);
if ($is_dynamic) {
$target .= "&_glpi_tab=PluginFusioninventoryDeployGroup_Dynamicdata$1";
} else {
$target.= "&_glpi_tab=PluginFusioninventoryDeployGroup_Staticdata$1";
}
$target.= "&plugin_fusioninventory_deploygroups_id=".$deploygroup_id;
return $target;
}
/**
* Show criteria to search computers
*
* @param object $item PluginFusioninventoryDeployGroup instance
* @param array $p
*/
static function showCriteria(PluginFusioninventoryDeployGroup $item, $p) {
$is_dynamic = $item->isDynamicGroup();
$itemtype = "PluginFusioninventoryComputer";
$can_update = $item->canEdit($item->getID());
$p['target'] = self::getSearchEngineTargetURL($item->getID(), $is_dynamic);
if ($can_update) {
$p['addhidden'] = [
'plugin_fusioninventory_deploygroups_id' => $item->getID(),
'id' => $item->getID(),
'start' => 0
];
}
if ($is_dynamic) {
$p['actionname'] = 'save';
$p['actionvalue'] = _sx('button', 'Save');
} else {
$p['actionname'] = 'preview';
$p['actionvalue'] = __('Preview');
}
$p['showbookmark'] = false;
Search::showGenericSearch($itemtype, $p);
}
/**
* Get targets for the group
*
* @param integer $groups_id id of the group
* @param bool $use_cache retrieve agents from cache or not (only for dynamic groups)
* @return array list of computers
*/
static function getTargetsForGroup($groups_id, $use_cache = false) {
$group = new self();
$group->getFromDB($groups_id);
$results = [];
if ($group->isStaticGroup()) {
$staticgroup = new PluginFusioninventoryDeployGroup_Staticdata();
foreach ($staticgroup->find(
['plugin_fusioninventory_deploygroups_id' => $groups_id,
'itemtype' => 'Computer']) as $tmpgroup) {
$results[$tmpgroup['items_id']] = $tmpgroup['items_id'];
}
} else {
$results = PluginFusioninventoryDeployGroup_Dynamicdata::getTargetsByGroup($group,
$use_cache);
}
return $results;
}
/**
* Get search parameters as an array
*
* @global object $DB
* @param object $group PluginFusioninventoryDeployGroup instance
* @param boolean $check_post_values
* @param boolean $getAll
* @return array
*/
static function getSearchParamsAsAnArray(PluginFusioninventoryDeployGroup $group, $check_post_values = false, $getAll = false) {
global $DB;
$computers_params = [];
//Check criteria from DB
if (!$check_post_values) {
if ($group->fields['type'] == PluginFusioninventoryDeployGroup::DYNAMIC_GROUP) {
unset($_SESSION['glpisearch']['PluginFusioninventoryComputer']);
$query = "SELECT `fields_array`
FROM `glpi_plugin_fusioninventory_deploygroups_dynamicdatas`
WHERE `plugin_fusioninventory_deploygroups_id`='".$group->getID()."'";
$result = $DB->query($query);
if ($DB->numrows($result) > 0) {
$fields_array = $DB->result($result, 0, 'fields_array');
$computers_params = unserialize($fields_array);
}
}
} else {
if ($group->fields['type'] == PluginFusioninventoryDeployGroup::STATIC_GROUP
&& isset($_SESSION['glpisearch']['PluginFusioninventoryComputer'])
&& !isset($_SESSION['glpisearch']['PluginFusioninventoryComputer']['show_results'])) {
$computers_params = $_SESSION['glpisearch']['PluginFusioninventoryComputer'];
} else {
unset($_SESSION['glpisearch']['PluginFusioninventoryComputer']);
$computers_params = $_GET;
}
}
if ($getAll) {
$computers_params['export_all'] = true;
}
return Search::manageParams('PluginFusioninventoryComputer', $computers_params);
}
/**
* Clean when purge a deploy group
*/
function cleanDBOnPurge() {
$dynamic_group = new PluginFusioninventoryDeployGroup_Dynamicdata();
$static_group = new PluginFusioninventoryDeployGroup_Staticdata();
$params = ['plugin_fusioninventory_deploygroups_id' => $this->getID()];
$dynamic_group->deleteByCriteria($params);
$static_group->deleteByCriteria($params);
}
/**
* Display for a computer the groups where it is
*
* @param integer $computers_id
*/
function showForComputer($computers_id) {
global $DB;
echo "<table width='950' class='tab_cadre_fixe'>";
echo "<tr>";
echo "<th>";
echo __('Group');
echo "</th>";
echo "<th>";
echo __('Type');
echo "</th>";
echo "</tr>";
$link = Toolbox::getItemTypeFormURL("PluginFusioninventoryDeployGroup");
$iterator = $DB->request([
'FROM' => PluginFusioninventoryDeployGroup_Staticdata::getTable(),
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
],
]);
foreach ($iterator as $data) {
$this->getFromDB($data['plugin_fusioninventory_deploygroups_id']);
echo "<tr>";
echo "<td>";
echo "<a href='".$link."?id=".$this->fields['id']."'>".$this->fields['name']."</a>";
echo "</td>";
echo "<td>";
echo __('Static group', 'fusioninventory');
echo "</td>";
echo "</tr>";
}
$iterator = $DB->request([
'FROM' => PluginFusioninventoryDeployGroup_Dynamicdata::getTable(),
'WHERE' => [
'computers_id_cache' => ["LIKE", '%"'.$computers_id.'"%'],
],
]);
foreach ($iterator as $data) {
$this->getFromDB($data['plugin_fusioninventory_deploygroups_id']);
echo "<tr>";
echo "<td>";
echo "<a href='".$link."?id=".$this->fields['id']."'>".$this->fields['name']."</a>";
echo "</td>";
echo "<td>";
echo __('Dynamic group', 'fusioninventory');
echo "</td>";
echo "</tr>";
}
echo "</table>";
}
}
Zerion Mini Shell 1.0