%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 update / add information of computer
* inventory into GLPI database.
*
* ------------------------------------------------------------------------
*
* @package FusionInventory
* @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 update / add information of computer inventory into GLPI database.
*/
class PluginFusioninventoryInventoryComputerLib extends PluginFusioninventoryInventoryCommon {
/**
* Define the name of the table
*
* @var string
*/
var $table = "glpi_plugin_fusioninventory_inventorycomputerlibserialization";
/**
* Initialize the list of software
*
* @var array
*/
var $softList = [];
/**
* Initialize the list of software versions
*
* @var array
*/
var $softVersionList = [];
/**
* Initilize the list of logs to add in the database
*
* @var array
*/
var $log_add = [];
/**
* Initilize a list of installation that should not be logged
*
* @var array
*/
var $installationWithoutLogs = [];
/**
* __contruct function where initialize many variables
*/
function __construct() {
$this->software = new Software();
$this->softwareVersion = new SoftwareVersion();
$this->computerSoftwareVersion = new Item_SoftwareVersion();
$this->softcatrule = new RuleSoftwareCategoryCollection();
$this->computer = new Computer();
}
/**
* Update computer data
*
* @global object $DB
* @global array $CFG_GLPI
* @param array $a_computerinventory all data from the agent
* @param integer $computers_id id of the computer
* @param boolean $no_history set true if not want history
* @param integer $setdynamic
*/
function updateComputer($a_computerinventory, $computers_id, $no_history, $setdynamic = 0) {
global $DB, $CFG_GLPI;
$computer = new Computer();
$pfInventoryComputerComputer = new PluginFusioninventoryInventoryComputerComputer();
$item_DeviceProcessor = new Item_DeviceProcessor();
$deviceProcessor = new DeviceProcessor();
$item_DeviceMemory = new Item_DeviceMemory();
$deviceMemory = new DeviceMemory();
$item_DeviceBattery = new Item_DeviceBattery();
$deviceBattery = new DeviceBattery();
$computerVirtualmachine = new ComputerVirtualMachine();
$itemDisk = new Item_Disk();
$item_DeviceControl = new Item_DeviceControl();
$item_DeviceHardDrive = new Item_DeviceHardDrive();
$item_DeviceDrive = new Item_DeviceDrive();
$item_DeviceGraphicCard = new Item_DeviceGraphicCard();
$item_DeviceNetworkCard = new Item_DeviceNetworkCard();
$item_DeviceSoundCard = new Item_DeviceSoundCard();
$item_DeviceBios = new Item_DeviceFirmware();
$domain_Item = new Domain_Item();
$pfInventoryComputerAntivirus = new ComputerAntivirus();
$pfConfig = new PluginFusioninventoryConfig();
$pfComputerLicenseInfo = new PluginFusioninventoryComputerLicenseInfo();
$computer_Item = new Computer_Item();
$monitor = new Monitor();
$printer = new Printer();
$peripheral = new Peripheral();
$pfComputerRemotemgmt = new PluginFusioninventoryComputerRemoteManagement();
$cronTask = new PluginFusioninventoryCronTask();
$computer->getFromDB($computers_id);
$a_lockable = PluginFusioninventoryLock::getLockFields('glpi_computers', $computers_id);
$importExternalDevices = true;
// Pass rule to know if it's a computer in remote work
$inputRuleRemotework = [];
foreach ($a_computerinventory['networkport'] as $network) {
foreach ($network['ipaddress'] as $ip) {
if ($ip != '127.0.0.1' && $ip != '::1') {
$inputRuleRemotework['ip'][] = $ip;
}
}
}
$ruleRemotework = new PluginFusioninventoryInventoryRuleRemoteworkCollection();
// * Reload rules (required for unit tests)
$ruleRemotework->getCollectionPart();
$dataRemotework = $ruleRemotework->processAllRules($inputRuleRemotework, []);
if (isset($dataRemotework['_ignore_external_devices'])) {
$importExternalDevices = false;
}
// Manage operating system
if (isset($a_computerinventory['fusioninventorycomputer']['items_operatingsystems_id'])
&& $a_computerinventory['fusioninventorycomputer']['items_operatingsystems_id']['operatingsystems_id'] != '') {
$ios = new Item_OperatingSystem();
$pfos = $a_computerinventory['fusioninventorycomputer']['items_operatingsystems_id'];
$input_os = [
'itemtype' => 'Computer',
'items_id' => $computers_id,
'operatingsystemarchitectures_id' => $pfos['operatingsystemarchitectures_id'],
'operatingsystemkernelversions_id' => $pfos['operatingsystemkernelversions_id'],
'operatingsystems_id' => $pfos['operatingsystems_id'],
'operatingsystemversions_id' => $pfos['operatingsystemversions_id'],
'operatingsystemservicepacks_id' => $pfos['operatingsystemservicepacks_id'],
'operatingsystemeditions_id' => $pfos['operatingsystemeditions_id'],
'licenseid' => $pfos['licenseid'],
'license_number' => $pfos['license_number'],
'is_dynamic' => 1,
'entities_id' => $computer->fields['entities_id']
];
$iterator = $DB->request([
'SELECT' => [
'id'
],
'FROM' => 'glpi_items_operatingsystems',
'WHERE' => [
'itemtype' => 'Computer',
'items_id' => $computers_id
]
]);
$firstFound = 0;
foreach ($iterator as $data) {
if ($firstFound > 0) {
$ios->delete(['id' => $data['id']], true);
} else {
$firstFound = $data['id'];
}
}
if ($firstFound > 0) {
$ret = $ios->update(['id' => $firstFound] + $input_os);
} else {
$input_os['_no_history'] = $no_history;
$ios->add($input_os);
}
}
if ($pfConfig->getValue("component_simcard") != 0) {
//Import simcards
$this->importSimcards('Computer', $a_computerinventory, $computers_id, $no_history);
}
// Manage the fields have ' in the field to prevent SQL error
$a_computerinventory = Toolbox::addslashes_deep($a_computerinventory);
// * Computer
$db_computer = $computer->fields;
// manage auto inventory number
if ($computer->fields['otherserial'] == ''
&& (!isset($a_computerinventory['Computer']['otherserial'])
|| $a_computerinventory['Computer']['otherserial'] == '')) {
$a_computerinventory['Computer']['otherserial'] = PluginFusioninventoryToolbox::setInventoryNumber(
'Computer', '', $computer->fields['entities_id']);
}
$a_ret = PluginFusioninventoryToolbox::checkLock($a_computerinventory['Computer'],
$db_computer, $a_lockable);
$a_computerinventory['Computer'] = $a_ret[0];
$input = $a_computerinventory['Computer'];
$input['id'] = $computers_id;
$history = true;
if ($no_history) {
$history = false;
}
$input['_no_history'] = $no_history;
if (!in_array('states_id', $a_lockable)) {
$input = PluginFusioninventoryToolbox::addDefaultStateIfNeeded('computer', $input);
}
$computer->update($input, !$no_history);
$this->computer = $computer;
// * Computer fusion (ext)
$db_computer = [];
if ($no_history === false) {
$iterator = $DB->request([
'FROM' => 'glpi_plugin_fusioninventory_inventorycomputercomputers',
'WHERE' => ['computers_id' => $computers_id],
'START' => 0,
'LIMIT' => 1
]);
foreach ($iterator as $data) {
foreach ($data as $key=>$value) {
$data[$key] = Toolbox::addslashes_deep($value);
}
$db_computer = $data;
}
}
if (count($db_computer) == '0') { // Add
$a_computerinventory['fusioninventorycomputer']['computers_id'] = $computers_id;
$pfInventoryComputerComputer->add($a_computerinventory['fusioninventorycomputer'],
[], false);
} else { // Update
if (!empty($db_computer['serialized_inventory'])) {
$setdynamic = 0;
}
$idtmp = $db_computer['id'];
unset($db_computer['id']);
unset($db_computer['computers_id']);
$a_ret = PluginFusioninventoryToolbox::checkLock(
$a_computerinventory['fusioninventorycomputer'],
$db_computer);
$a_computerinventory['fusioninventorycomputer'] = $a_ret[0];
$db_computer = $a_ret[1];
$input = $a_computerinventory['fusioninventorycomputer'];
$input['id'] = $idtmp;
$input['_no_history'] = $no_history;
$pfInventoryComputerComputer->update($input, !$no_history);
}
// Put all link item dynamic (in case of update computer not yet inventoried with fusion)
if ($setdynamic == 1) {
$this->setDynamicLinkItems($computers_id);
}
// * Domain
if ($pfConfig->getValue('import_domain') == 1) {
$db_domain = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'id',
'domains_id'
],
'FROM' => 'glpi_domains_items',
'WHERE' => [
'itemtype' => 'Computer',
'items_id' => $computers_id
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$db_domain[$idtmp] = $data['domains_id'];
}
}
if (count($db_domain) == 0) {
if (isset($a_computerinventory['Computer']['domains_id'])
&& !empty($a_computerinventory['Computer']['domains_id'])) {
$this->addDomain($a_computerinventory['Computer']['domains_id'], $computers_id, $no_history);
}
} else {
$foundDomain = false;
if (isset($a_computerinventory['Computer']['domains_id'])
&& !empty($a_computerinventory['Computer']['domains_id'])) {
foreach ($db_domain as $keydb => $domains_id) {
if ($a_computerinventory['Computer']['domains_id'] == $domains_id) {
unset($db_domain[$keydb]);
$foundDomain = true;
break;
}
}
}
if (count($db_domain) != 0) {
// Delete Domain in DB
foreach ($db_domain as $idtmp => $domains_id) {
$domain_Item->delete(['id'=>$idtmp], 1);
}
}
if (!$foundDomain
&& isset($a_computerinventory['Computer']['domains_id'])
&& !empty($a_computerinventory['Computer']['domains_id'])) {
$this->addDomain($a_computerinventory['Computer']['domains_id'], $computers_id, $no_history);
}
}
}
// * BIOS
$db_bios = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'glpi_items_devicefirmwares.id',
'serial',
'designation',
'version'
],
'FROM' => 'glpi_items_devicefirmwares',
'LEFT JOIN' => [
'glpi_devicefirmwares' => [
'FKEY' => [
'glpi_items_devicefirmwares' => 'devicefirmwares_id',
'glpi_devicefirmwares' => 'id'
]
]
],
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$data2 = array_map('strtolower', $data1);
$db_bios[$idtmp] = $data2;
}
}
if (count($db_bios) == 0) {
if (isset($a_computerinventory['bios'])
&& !empty($a_computerinventory['bios'])) {
$this->addBios($a_computerinventory['bios'], $computers_id, $no_history);
}
} else {
if (isset($a_computerinventory['bios'])
&& !empty($a_computerinventory['bios'])) {
$arrayslower = array_map('strtolower', $a_computerinventory['bios']);
foreach ($db_bios as $keydb => $arraydb) {
if (isset($arrayslower['version']) && $arrayslower['version'] == $arraydb['version']) {
unset($a_computerinventory['bios']);
unset($db_bios[$keydb]);
break;
}
}
}
if (count($db_bios) != 0) {
// Delete BIOS in DB
foreach ($db_bios as $idtmp => $data) {
$item_DeviceBios->delete(['id'=>$idtmp], 1);
}
}
if (isset($a_computerinventory['bios'])) {
$this->addBios($a_computerinventory['bios'], $computers_id, $no_history);
}
}
// * Processors
if ($pfConfig->getValue("component_processor") != 0) {
$db_processors = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'glpi_items_deviceprocessors.id',
'designation',
'frequency',
'frequence',
'frequency_default',
'serial',
'manufacturers_id',
'glpi_items_deviceprocessors.nbcores',
'glpi_items_deviceprocessors.nbthreads'
],
'FROM' => 'glpi_items_deviceprocessors',
'LEFT JOIN' => [
'glpi_deviceprocessors' => [
'FKEY' => [
'glpi_deviceprocessors' => 'id',
'glpi_items_deviceprocessors' => 'deviceprocessors_id'
]
]
],
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$db_processors[$idtmp] = Toolbox::addslashes_deep($data);
}
}
if (count($db_processors) == 0) {
foreach ($a_computerinventory['processor'] as $a_processor) {
$this->addProcessor($a_processor, $computers_id, $no_history);
}
} else {
// Check all fields from source: 'designation', 'serial', 'manufacturers_id',
// 'frequence'
foreach ($a_computerinventory['processor'] as $key => $arrays) {
$frequence = $arrays['frequence'];
unset($arrays['frequence']);
unset($arrays['frequency']);
unset($arrays['frequency_default']);
foreach ($db_processors as $keydb => $arraydb) {
$frequencedb = $arraydb['frequence'];
unset($arraydb['frequence']);
unset($arraydb['frequency']);
unset($arraydb['frequency_default']);
if ($arrays == $arraydb) {
$a_criteria = $deviceProcessor->getImportCriteria();
$criteriafrequence = $a_criteria['frequence'];
$compare = explode(':', $criteriafrequence);
if ($frequence > ($frequencedb - $compare[1])
&& $frequence < ($frequencedb + $compare[1])) {
unset($a_computerinventory['processor'][$key]);
unset($db_processors[$keydb]);
break;
}
}
}
}
if (count($a_computerinventory['processor']) || count($db_processors)) {
if (count($db_processors) != 0) {
// Delete processor in DB
foreach ($db_processors as $idtmp => $data) {
$item_DeviceProcessor->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['processor']) != 0) {
foreach ($a_computerinventory['processor'] as $a_processor) {
$this->addProcessor($a_processor, $computers_id, $no_history);
}
}
}
}
}
// * Memories
if ($pfConfig->getValue("component_memory") != 0) {
$db_memories = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'glpi_items_devicememories.id',
'designation',
'size',
'frequence',
'serial',
'devicememorytypes_id',
'glpi_items_devicememories.busID',
],
'FROM' => 'glpi_items_devicememories',
'LEFT JOIN' => [
'glpi_devicememories' => [
'FKEY' => [
'glpi_devicememories' => 'id',
'glpi_items_devicememories' => 'devicememories_id'
]
]
],
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$db_memories[$idtmp] = $data1;
}
}
if (count($db_memories) == 0) {
foreach ($a_computerinventory['memory'] as $a_memory) {
$this->addMemory($a_memory, $computers_id, $no_history);
}
} else {
// Check all fields from source: 'designation', 'serial', 'size',
// 'devicememorytypes_id', 'frequence'
foreach ($a_computerinventory['memory'] as $key => $arrays) {
$frequence = (int) $arrays['frequence'];
unset($arrays['frequence']);
foreach ($db_memories as $keydb => $arraydb) {
$frequencedb = (int) $arraydb['frequence'];
unset($arraydb['frequence']);
if ($arrays == $arraydb) {
$a_criteria = $deviceMemory->getImportCriteria();
$criteriafrequence = $a_criteria['frequence'];
$compare = explode(':', $criteriafrequence);
if ($frequence > ($frequencedb - $compare[1])
&& $frequence < ($frequencedb + $compare[1])) {
unset($a_computerinventory['memory'][$key]);
unset($db_memories[$keydb]);
break;
}
}
}
}
if (count($a_computerinventory['memory']) || count($db_memories)) {
if (count($db_memories) != 0) {
// Delete memory in DB
foreach ($db_memories as $idtmp => $data) {
$item_DeviceMemory->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['memory']) != 0) {
foreach ($a_computerinventory['memory'] as $a_memory) {
$this->addMemory($a_memory, $computers_id, $no_history);
}
}
}
}
}
// * Hard drive
if ($pfConfig->getValue("component_harddrive") != 0) {
$db_harddrives = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'id',
'serial',
'capacity'
],
'FROM' => 'glpi_items_deviceharddrives',
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$data2 = array_map('strtolower', $data1);
$db_harddrives[$idtmp] = $data2;
}
}
if (count($db_harddrives) == 0) {
foreach ($a_computerinventory['harddrive'] as $a_harddrive) {
$this->addHardDisk($a_harddrive, $computers_id, $no_history);
}
} else {
foreach ($a_computerinventory['harddrive'] as $key => $arrays) {
$arrayslower = array_map('strtolower', $arrays);
// if disk has no serial, don't add and unset it
if (!isset($arrayslower['serial'])) {
unset($a_computerinventory['harddrive'][$key]);
break;
}
foreach ($db_harddrives as $keydb => $arraydb) {
if ($arrayslower['serial'] == $arraydb['serial']) {
if ($arrayslower['capacity'] > 0
&& $arraydb['capacity'] != $arrayslower['capacity']) {
$input = [
'id' => $keydb,
'capacity' => $arrayslower['capacity']
];
$item_DeviceHardDrive->update($input);
}
unset($a_computerinventory['harddrive'][$key]);
unset($db_harddrives[$keydb]);
break;
}
}
}
if (count($a_computerinventory['harddrive']) || count($db_harddrives)) {
if (count($db_harddrives) != 0) {
// Delete hard drive in DB
foreach ($db_harddrives as $idtmp => $data) {
$item_DeviceHardDrive->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['harddrive']) != 0) {
foreach ($a_computerinventory['harddrive'] as $a_harddrive) {
$this->addHardDisk($a_harddrive, $computers_id, $no_history);
}
}
}
}
}
// * drive
if ($pfConfig->getValue("component_drive") != 0) {
$db_drives = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'glpi_items_devicedrives.id',
'serial',
'glpi_devicedrives.designation'
],
'FROM' => 'glpi_items_devicedrives',
'LEFT JOIN' => [
'glpi_devicedrives' => [
'FKEY' => [
'glpi_devicedrives' => 'id',
'glpi_items_devicedrives' => 'devicedrives_id'
]
]
],
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$data2 = array_map('strtolower', $data1);
$db_drives[$idtmp] = $data2;
}
}
if (count($db_drives) == 0) {
foreach ($a_computerinventory['drive'] as $a_drive) {
$this->addDrive($a_drive, $computers_id, $no_history);
}
} else {
foreach ($a_computerinventory['drive'] as $key => $arrays) {
$arrayslower = array_map('strtolower', $arrays);
if ($arrayslower['serial'] == '') {
foreach ($db_drives as $keydb => $arraydb) {
if ($arrayslower['designation'] == $arraydb['designation']) {
unset($a_computerinventory['drive'][$key]);
unset($db_drives[$keydb]);
break;
}
}
} else {
foreach ($db_drives as $keydb => $arraydb) {
if ($arrayslower['serial'] == $arraydb['serial']) {
unset($a_computerinventory['drive'][$key]);
unset($db_drives[$keydb]);
break;
}
}
}
}
if (count($a_computerinventory['drive']) || count($db_drives)) {
if (count($db_drives) != 0) {
// Delete drive in DB
foreach ($db_drives as $idtmp => $data) {
$item_DeviceDrive->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['drive']) != 0) {
foreach ($a_computerinventory['drive'] as $a_drive) {
$this->addDrive($a_drive, $computers_id, $no_history);
}
}
}
}
}
// * Graphiccard
if ($pfConfig->getValue("component_graphiccard") != 0) {
$db_graphiccards = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'glpi_items_devicegraphiccards.id',
'designation',
'memory'
],
'FROM' => 'glpi_items_devicegraphiccards',
'LEFT JOIN' => [
'glpi_devicegraphiccards' => [
'FKEY' => [
'glpi_devicegraphiccards' => 'id',
'glpi_items_devicegraphiccards' => 'devicegraphiccards_id'
]
]
],
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
if (preg_match("/[^a-zA-Z0-9 \-_\(\)]+/", $data['designation'])) {
$data['designation'] = Toolbox::addslashes_deep($data['designation']);
}
$data['designation'] = trim(strtolower($data['designation']));
$db_graphiccards[$idtmp] = $data;
}
}
if (count($db_graphiccards) == 0) {
foreach ($a_computerinventory['graphiccard'] as $a_graphiccard) {
$this->addGraphicCard($a_graphiccard, $computers_id, $no_history);
}
} else {
// Check all fields from source: 'designation', 'memory'
foreach ($a_computerinventory['graphiccard'] as $key => $arrays) {
$arrays['designation'] = strtolower($arrays['designation']);
foreach ($db_graphiccards as $keydb => $arraydb) {
if ($arrays == $arraydb) {
unset($a_computerinventory['graphiccard'][$key]);
unset($db_graphiccards[$keydb]);
break;
}
}
}
if (count($a_computerinventory['graphiccard']) || count($db_graphiccards)) {
if (count($db_graphiccards) != 0) {
// Delete graphiccard in DB
foreach ($db_graphiccards as $idtmp => $data) {
$item_DeviceGraphicCard->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['graphiccard']) != 0) {
foreach ($a_computerinventory['graphiccard'] as $a_graphiccard) {
$this->addGraphicCard($a_graphiccard, $computers_id, $no_history);
}
}
}
}
}
// * networkcard
if ($pfConfig->getValue("component_networkcard") != 0) {
$db_networkcards = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'glpi_items_devicenetworkcards.id',
'designation',
'mac',
'manufacturers_id'
],
'FROM' => 'glpi_items_devicenetworkcards',
'LEFT JOIN' => [
'glpi_devicenetworkcards' => [
'FKEY' => [
'glpi_devicenetworkcards' => 'id',
'glpi_items_devicenetworkcards' => 'devicenetworkcards_id'
]
]
],
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
if (preg_match("/[^a-zA-Z0-9 \-_\(\)]+/", $data['designation'])) {
$data['designation'] = Toolbox::addslashes_deep($data['designation']);
}
$data['designation'] = trim(strtolower($data['designation']));
$db_networkcards[$idtmp] = $data;
}
}
if (count($db_networkcards) == 0) {
foreach ($a_computerinventory['networkcard'] as $a_networkcard) {
$this->addNetworkCard($a_networkcard, $computers_id, $no_history);
}
} else {
// Check all fields from source: 'designation', 'mac'
foreach ($a_computerinventory['networkcard'] as $key => $arrays) {
$arrays['designation'] = strtolower($arrays['designation']);
foreach ($db_networkcards as $keydb => $arraydb) {
if ($arrays == $arraydb) {
unset($a_computerinventory['networkcard'][$key]);
unset($db_networkcards[$keydb]);
break;
}
}
}
if (count($a_computerinventory['networkcard']) || count($db_networkcards)) {
if (count($db_networkcards) != 0) {
// Delete networkcard in DB
foreach ($db_networkcards as $idtmp => $data) {
$item_DeviceNetworkCard->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['networkcard']) != 0) {
foreach ($a_computerinventory['networkcard'] as $a_networkcard) {
$this->addNetworkCard($a_networkcard, $computers_id, $no_history);
}
}
}
}
}
// * Sound
if ($pfConfig->getValue("component_soundcard") != 0) {
$db_soundcards = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'glpi_items_devicesoundcards.id',
'designation',
'comment',
'manufacturers_id'
],
'FROM' => 'glpi_items_devicesoundcards',
'LEFT JOIN' => [
'glpi_devicesoundcards' => [
'FKEY' => [
'glpi_devicesoundcards' => 'id',
'glpi_items_devicesoundcards' => 'devicesoundcards_id'
]
]
],
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$db_soundcards[$idtmp] = $data1;
}
}
if (count($db_soundcards) == 0) {
foreach ($a_computerinventory['soundcard'] as $a_soundcard) {
$this->addSoundCard($a_soundcard, $computers_id, $no_history);
}
} else {
// Check all fields from source: 'designation', 'memory', 'manufacturers_id'
foreach ($a_computerinventory['soundcard'] as $key => $arrays) {
// $arrayslower = array_map('strtolower', $arrays);
$arrayslower = $arrays;
foreach ($db_soundcards as $keydb => $arraydb) {
if ($arrayslower == $arraydb) {
unset($a_computerinventory['soundcard'][$key]);
unset($db_soundcards[$keydb]);
break;
}
}
}
if (count($a_computerinventory['soundcard']) || count($db_soundcards)) {
if (count($db_soundcards) != 0) {
// Delete soundcard in DB
foreach ($db_soundcards as $idtmp => $data) {
$item_DeviceSoundCard->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['soundcard']) != 0) {
foreach ($a_computerinventory['soundcard'] as $a_soundcard) {
$this->addSoundCard($a_soundcard, $computers_id, $no_history);
}
}
}
}
}
// * Controllers
if ($pfConfig->getValue("component_control") != 0) {
$db_controls = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'glpi_items_devicecontrols.id',
'interfacetypes_id',
'manufacturers_id',
'designation'
],
'FROM' => 'glpi_items_devicecontrols',
'LEFT JOIN' => [
'glpi_devicecontrols' => [
'FKEY' => [
'glpi_devicecontrols' => 'id',
'glpi_items_devicecontrols' => 'devicecontrols_id'
]
]
],
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$data2 = array_map('strtolower', $data1);
$db_controls[$idtmp] = $data2;
}
}
if (count($db_controls) == 0) {
foreach ($a_computerinventory['controller'] as $a_control) {
$this->addControl($a_control, $computers_id, $no_history);
}
} else {
// Check all fields from source:
foreach ($a_computerinventory['controller'] as $key => $arrays) {
$arrayslower = array_map('strtolower', $arrays);
foreach ($db_controls as $keydb => $arraydb) {
if ($arrayslower == $arraydb) {
unset($a_computerinventory['controller'][$key]);
unset($db_controls[$keydb]);
break;
}
}
}
if (count($a_computerinventory['controller']) || count($db_controls)) {
if (count($db_controls) != 0) {
// Delete controller in DB
foreach ($db_controls as $idtmp => $data) {
$item_DeviceControl->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['controller']) != 0) {
foreach ($a_computerinventory['controller'] as $a_control) {
$this->addControl($a_control, $computers_id, $no_history);
}
}
}
}
}
// * Software
if ($pfConfig->getValue("import_software") != 0) {
$this->importSoftware('Computer', $a_computerinventory, $computer, $no_history);
}
// * Virtualmachines
if ($pfConfig->getValue("import_vm") == 1) {
$db_computervirtualmachine = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => ['id', 'name', 'uuid', 'virtualmachinesystems_id'],
'FROM' => 'glpi_computervirtualmachines',
'WHERE' => [
'computers_id' => $computers_id,
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$db_computervirtualmachine[$idtmp] = $data1;
}
}
$simplecomputervirtualmachine = [];
if (isset($a_computerinventory['virtualmachine'])) {
foreach ($a_computerinventory['virtualmachine'] as $key=>$a_computervirtualmachine) {
$a_field = ['name', 'uuid', 'virtualmachinesystems_id'];
foreach ($a_field as $field) {
if (isset($a_computervirtualmachine[$field])) {
$simplecomputervirtualmachine[$key][$field] = $a_computervirtualmachine[$field];
}
}
}
}
foreach ($simplecomputervirtualmachine as $key => $arrays) {
foreach ($db_computervirtualmachine as $keydb => $arraydb) {
if ($arrays == $arraydb) {
$input = [];
$input['id'] = $keydb;
if (isset($a_computerinventory['virtualmachine'][$key]['vcpu'])) {
$input['vcpu'] = $a_computerinventory['virtualmachine'][$key]['vcpu'];
}
if (isset($a_computerinventory['virtualmachine'][$key]['ram'])) {
$input['ram'] = $a_computerinventory['virtualmachine'][$key]['ram'];
}
if (isset($a_computerinventory['virtualmachine'][$key]['virtualmachinetypes_id'])) {
$input['virtualmachinetypes_id'] =
$a_computerinventory['virtualmachine'][$key]['virtualmachinetypes_id'];
}
if (isset($a_computerinventory['virtualmachine'][$key]['virtualmachinestates_id'])) {
$input['virtualmachinestates_id'] =
$a_computerinventory['virtualmachine'][$key]['virtualmachinestates_id'];
}
$computerVirtualmachine->update($input, !$no_history);
unset($simplecomputervirtualmachine[$key]);
unset($a_computerinventory['virtualmachine'][$key]);
unset($db_computervirtualmachine[$keydb]);
break;
}
}
}
if (count($a_computerinventory['virtualmachine']) || count($db_computervirtualmachine)) {
if (count($db_computervirtualmachine) != 0) {
// Delete virtualmachine in DB
foreach ($db_computervirtualmachine as $idtmp => $data) {
$computerVirtualmachine->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['virtualmachine']) != 0) {
foreach ($a_computerinventory['virtualmachine'] as $a_virtualmachine) {
$a_virtualmachine['computers_id'] = $computers_id;
$computerVirtualmachine->add($a_virtualmachine, [], !$no_history);
}
}
}
}
if ($pfConfig->getValue("create_vm") == 1) {
// Create VM based on information of section VIRTUALMACHINE
$pfAgent = new PluginFusioninventoryAgent();
// Use ComputerVirtualMachine::getUUIDRestrictRequest to get existant
// vm in computer list
$computervm = new Computer();
if (isset($a_computerinventory['virtualmachine_creation'])
&& is_array($a_computerinventory['virtualmachine_creation'])) {
foreach ($a_computerinventory['virtualmachine_creation'] as $a_vm) {
// Define location of physical computer (host)
$a_vm['locations_id'] = $computer->fields['locations_id'];
if (isset($a_vm['uuid'])
&& $a_vm['uuid'] != '') {
$iterator = $DB->request([
'FROM' => 'glpi_computers',
'WHERE' => [
'RAW' => [
'LOWER(uuid)' => ComputerVirtualMachine::getUUIDRestrictCriteria($a_vm['uuid'])
]
],
'LIMIT' => 1
]);
$computers_vm_id = 0;
foreach ($iterator as $data) {
$computers_vm_id = $data['id'];
}
if ($computers_vm_id == 0) {
// Add computer
$a_vm['entities_id'] = $computer->fields['entities_id'];
$computers_vm_id = $computervm->add($a_vm, [], !$no_history);
// Manage networks
$this->manageNetworkPort($a_vm['networkport'], $computers_vm_id, false);
} else {
if ($pfAgent->getAgentWithComputerid($computers_vm_id) === false) {
// Update computer
$a_vm['id'] = $computers_vm_id;
$computervm->update($a_vm, !$no_history);
// Manage networks
$this->manageNetworkPort($a_vm['networkport'], $computers_vm_id, false);
}
}
}
}
}
}
// * Item_Disk
if ($pfConfig->getValue("import_volume") != 0) {
$db_itemdisk = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => ['id', 'name', 'device', 'mountpoint'],
'FROM' => 'glpi_items_disks',
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$data2 = array_map('strtolower', $data1);
$db_itemdisk[$idtmp] = $data2;
}
}
$simpleitemdisk = [];
foreach ($a_computerinventory['computerdisk'] as $key=>$a_itemdisk) {
$a_field = ['name', 'device', 'mountpoint'];
foreach ($a_field as $field) {
if (isset($a_itemdisk[$field])) {
$simpleitemdisk[$key][$field] = $a_itemdisk[$field];
}
}
}
foreach ($simpleitemdisk as $key => $arrays) {
$arrayslower = array_map('strtolower', $arrays);
foreach ($db_itemdisk as $keydb => $arraydb) {
if ($arrayslower == $arraydb) {
$input = [];
$input['id'] = $keydb;
if (isset($a_computerinventory['computerdisk'][$key]['filesystems_id'])) {
$input['filesystems_id'] =
$a_computerinventory['computerdisk'][$key]['filesystems_id'];
}
$input['totalsize'] = $a_computerinventory['computerdisk'][$key]['totalsize'];
$input['freesize'] = $a_computerinventory['computerdisk'][$key]['freesize'];
$disk = $a_computerinventory['computerdisk'][$key];
// Safecheck until GLPI X
if (defined('Item_Disk::ENCRYPTION_STATUS_YES') && isset($a_itemdisk['encryption_status'])) {
// Encryption status
if ($disk['encryption_status'] == "Yes") {
$input['encryption_status'] = Item_Disk::ENCRYPTION_STATUS_YES;
} else if ($disk['encryption_status'] == "Partially") {
$input['encryption_status'] = Item_Disk::ENCRYPTION_STATUS_PARTIALLY;
} else {
$input['encryption_status'] = Item_Disk::ENCRYPTION_STATUS_NO;
}
// Encryption details
$input['encryption_tool'] = $disk['encryption_tool'] ?? null;
$input['encryption_algorithm'] = $disk['encryption_algorithm'] ?? null;
$input['encryption_type'] = $disk['encrypt_type'] ?? null;
}
$input['_no_history'] = true;
$itemDisk->update($input, false);
unset($simpleitemdisk[$key]);
unset($a_computerinventory['computerdisk'][$key]);
unset($db_itemdisk[$keydb]);
break;
}
}
}
if (count($a_computerinventory['computerdisk']) || count($db_itemdisk)) {
if (count($db_itemdisk) != 0) {
// Delete Item_Disk in DB
foreach ($db_itemdisk as $idtmp => $data) {
$itemDisk->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['computerdisk']) != 0) {
foreach ($a_computerinventory['computerdisk'] as $a_itemdisk) {
$a_itemdisk['items_id'] = $computers_id;
$a_itemdisk['itemtype'] = 'Computer';
$a_itemdisk['is_dynamic'] = 1;
// Safecheck until GLPI X
if (defined('Item_Disk::ENCRYPTION_STATUS_YES') && isset($a_itemdisk['encryption_status'])) {
//Encryption status
if ($a_itemdisk['encryption_status'] == "Yes") {
$a_itemdisk['encryption_status'] = Item_Disk::ENCRYPTION_STATUS_YES;
} else if ($a_itemdisk['encryption_status'] == "Partially") {
$a_itemdisk['encryption_status'] = Item_Disk::ENCRYPTION_STATUS_PARTIALLY;
} else {
$a_itemdisk['encryption_status'] = Item_Disk::ENCRYPTION_STATUS_NO;
}
}
$a_itemdisk['_no_history'] = $no_history;
$itemDisk->add($a_itemdisk, [], !$no_history);
}
}
}
}
// * Networkports
if ($pfConfig->getValue("component_networkcard") != 0) {
// Get port from unmanaged device if exist
$this->manageNetworkPort($a_computerinventory['networkport'], $computers_id, $no_history);
}
// * Antivirus
if ($pfConfig->getValue("import_antivirus") != 0) {
$db_antivirus = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => ['id', 'name', 'antivirus_version'],
'FROM' => $pfInventoryComputerAntivirus->getTable(),
'WHERE' => ['computers_id' => $computers_id]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$data2 = array_map('strtolower', $data1);
$db_antivirus[$idtmp] = $data2;
}
}
$simpleantivirus = [];
foreach ($a_computerinventory['antivirus'] as $key=>$a_antivirus) {
$a_field = ['name', 'antivirus_version'];
foreach ($a_field as $field) {
if (isset($a_antivirus[$field])) {
$simpleantivirus[$key][$field] = $a_antivirus[$field];
}
}
}
foreach ($simpleantivirus as $key => $arrays) {
$arrayslower = array_map('strtolower', $arrays);
foreach ($db_antivirus as $keydb => $arraydb) {
if ($arrayslower == $arraydb) {
$input = [];
$input = $a_computerinventory['antivirus'][$key];
$input['id'] = $keydb;
$input['is_dynamic'] = 1;
$pfInventoryComputerAntivirus->update($input, !$no_history);
unset($simpleantivirus[$key]);
unset($a_computerinventory['antivirus'][$key]);
unset($db_antivirus[$keydb]);
break;
}
}
}
if (count($a_computerinventory['antivirus']) || count($db_antivirus)) {
if (count($db_antivirus) != 0) {
foreach ($db_antivirus as $idtmp => $data) {
$pfInventoryComputerAntivirus->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['antivirus']) != 0) {
foreach ($a_computerinventory['antivirus'] as $a_antivirus) {
$a_antivirus['computers_id'] = $computers_id;
$a_antivirus['is_dynamic'] = 1;
$pfInventoryComputerAntivirus->add($a_antivirus, [], !$no_history);
}
}
}
}
// * Licenseinfo
$db_licenseinfo = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => ['id', 'name', 'fullname', 'serial'],
'FROM' => 'glpi_plugin_fusioninventory_computerlicenseinfos',
'WHERE' => ['computers_id' => $computers_id]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$data2 = array_map('strtolower', $data1);
$db_licenseinfo[$idtmp] = $data2;
}
}
foreach ($a_computerinventory['licenseinfo'] as $key => $arrays) {
$arrayslower = array_map('strtolower', $arrays);
foreach ($db_licenseinfo as $keydb => $arraydb) {
if ($arrayslower == $arraydb) {
unset($a_computerinventory['licenseinfo'][$key]);
unset($db_licenseinfo[$keydb]);
break;
}
}
}
if (count($a_computerinventory['licenseinfo']) || count($db_licenseinfo)) {
if (count($db_licenseinfo) != 0) {
foreach ($db_licenseinfo as $idtmp => $data) {
$pfComputerLicenseInfo->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['licenseinfo']) != 0) {
foreach ($a_computerinventory['licenseinfo'] as $a_licenseinfo) {
$a_licenseinfo['computers_id'] = $computers_id;
$pfComputerLicenseInfo->add($a_licenseinfo, [], !$no_history);
}
}
}
// * Remote_mgmt
$db_remotemgmt = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => ['id', 'type', 'number'],
'FROM' => 'glpi_plugin_fusioninventory_computerremotemanagements',
'WHERE' => ['computers_id' => $computers_id]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data1 = Toolbox::addslashes_deep($data);
$data2 = array_map('strtolower', $data1);
$db_remotemgmt[$idtmp] = $data2;
}
}
foreach ($a_computerinventory['remote_mgmt'] as $key => $arrays) {
$arrayslower = array_map('strtolower', $arrays);
foreach ($db_remotemgmt as $keydb => $arraydb) {
if ($arrayslower == $arraydb) {
unset($a_computerinventory['remote_mgmt'][$key]);
unset($db_remotemgmt[$keydb]);
break;
}
}
}
if (count($a_computerinventory['remote_mgmt']) || count($db_remotemgmt)) {
if (count($db_remotemgmt) != 0) {
foreach ($db_remotemgmt as $idtmp => $data) {
$pfComputerRemotemgmt->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory['remote_mgmt']) != 0) {
foreach ($a_computerinventory['remote_mgmt'] as $a_remotemgmt) {
$a_remotemgmt['computers_id'] = $computers_id;
$pfComputerRemotemgmt->add($a_remotemgmt, [], !$no_history);
}
}
}
// * Batteries
if ($pfConfig->getValue("component_battery") != 0) {
$db_batteries = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'glpi_items_devicebatteries.id',
'serial',
'voltage',
'capacity'
],
'FROM' => 'glpi_items_devicebatteries',
'LEFT JOIN' => [
'glpi_devicebatteries' => [
'FKEY' => [
'glpi_devicebatteries' => 'id',
'glpi_items_devicebatteries' => 'devicebatteries_id'
]
]
],
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data = Toolbox::addslashes_deep($data);
$data = array_map('strtolower', $data);
$db_batteries[$idtmp] = $data;
}
}
if (count($db_batteries) == 0) {
foreach ($a_computerinventory['batteries'] as $a_battery) {
$this->addBattery($a_battery, $computers_id, $no_history);
}
} else {
// Check all fields from source: 'designation', 'serial', 'size',
// 'devicebatterytypes_id', 'frequence'
foreach ($a_computerinventory['batteries'] as $key => $arrays) {
$arrayslower = array_map('strtolower', $arrays);
foreach ($db_batteries as $keydb => $arraydb) {
if (isset($arrayslower['serial'])
&& isset($arraydb['serial'])
&& $arrayslower['serial'] == $arraydb['serial']
) {
$update = false;
if ($arraydb['capacity'] == 0
&& $arrayslower['capacity'] > 0) {
$input = [
'id' => $keydb,
'capacity' => $arrayslower['capacity']
];
$update = true;
}
if ($arraydb['voltage'] == 0
&& $arrayslower['voltage'] > 0) {
$input = [
'id' => $keydb,
'voltage' => $arrayslower['voltage']
];
$update = true;
}
if ($update === true) {
$item_DeviceMemory->update($input);
}
unset($a_computerinventory['batteries'][$key]);
unset($db_batteries[$keydb]);
break;
}
}
//delete remaining batteries in database
if (count($db_batteries) > 0) {
// Delete battery in DB
foreach ($db_batteries as $idtmp => $data) {
$item_DeviceBattery->delete(['id' => $idtmp], 1);
}
}
//add new batteries in database
if (count($a_computerinventory['batteries']) != 0) {
foreach ($a_computerinventory['batteries'] as $a_battery) {
$this->addBattery($a_battery, $computers_id, $no_history);
}
}
}
}
}
// * Crontasks
if ($pfConfig->getValue("import_crontask") != 0) {
$db_crontasks = [];
if ($no_history === false) {
$iterator = $DB->request([
'SELECT' => [
'id',
'name',
'storage',
'user_storage',
'user_id_storage'
],
'FROM' => 'glpi_plugin_fusioninventory_crontasks',
'WHERE' => [
'computers_id' => $computers_id
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
$data = Toolbox::addslashes_deep($data);
$data = array_map('strtolower', $data);
$db_crontasks[$idtmp] = $data;
}
}
if (count($db_crontasks) == 0) {
foreach ($a_computerinventory['crontasks'] as $a_crontask) {
if (isset($a_crontask['user_execution'])) {
$a_crontask['user_id_execution'] = $this->retrieveFusionInventoryCronTaskUserId($DB, $a_crontask['user_execution']);
}
if (isset($a_crontask['user_storage'])) {
$a_crontask['user_id_storage'] = $this->retrieveFusionInventoryCronTaskUserId($DB, $a_crontask['user_storage']);
}
$a_crontask['computers_id'] = $computers_id;
$this->addFusionInventoryCronTask($a_crontask, $no_history);
}
} else {
foreach ($a_computerinventory['crontasks'] as $key => $arrays) {
$arrayslower = array_map('strtolower', $arrays);
foreach ($db_crontasks as $keydb => $arraydb) {
if ($arrayslower['name'] == $arraydb['name']
&& $arrayslower['storage'] == $arraydb['storage']) {
$arrays['id'] = $keydb;
$cronTask->update($arrays);
unset($a_computerinventory['crontasks'][$key]);
unset($db_crontasks[$keydb]);
break;
}
}
}
//delete remaining crontasks in database
if (count($db_crontasks) > 0) {
foreach ($db_crontasks as $idtmp => $data) {
$cronTask->delete(['id' => $idtmp], 1);
}
}
//add new crontasks in database
if (count($a_computerinventory['crontasks']) != 0) {
foreach ($a_computerinventory['crontasks'] as $a_crontask) {
if (isset($a_crontask['user_execution'])) {
$a_crontask['user_id_execution'] = $this->retrieveFusionInventoryCronTaskUserId($DB, $a_crontask['user_execution']);
}
if (isset($a_crontask['user_storage'])) {
$a_crontask['user_id_storage'] = $this->retrieveFusionInventoryCronTaskUserId($DB, $a_crontask['user_storage']);
}
$a_crontask['computers_id'] = $computers_id;
$this->addFusionInventoryCronTask($a_crontask, $no_history);
}
}
}
}
$entities_id = $_SESSION["plugin_fusioninventory_entity"];
// * Monitors
if ($importExternalDevices) {
$rule = new PluginFusioninventoryInventoryRuleImportCollection();
$a_monitors = [];
foreach ($a_computerinventory['monitor'] as $key => $arrays) {
$input = [];
$input['itemtype'] = "Monitor";
$input['name'] = $arrays['name'];
$input['serial'] = isset($arrays['serial'])
? $arrays['serial']
: "";
$data = $rule->processAllRules($input, [], ['class'=>$this, 'return' => true]);
if (isset($data['found_equipment'])) {
if ($data['found_equipment'][0] == 0) {
// add monitor
$arrays['entities_id'] = $entities_id;
$arrays['otherserial'] = PluginFusioninventoryToolbox::setInventoryNumber(
'Monitor', '', $entities_id);
$a_monitors[] = $monitor->add($arrays);
} else {
$a_monitors[] = $data['found_equipment'][0];
// Check monitor information to update if not good (in case of modification in agent for example)
$monitor->getFromDB($data['found_equipment'][0]);
$input = [];
$input['id'] = $data['found_equipment'][0];
foreach (['manufacturers_id', 'name', 'monitormodels_id'] as $key) {
if ($monitor->fields[$key] !== $arrays[$key] && !empty($arrays[$key])) {
$input[$key] = $arrays[$key];
}
}
if (count($input) > 1) {
$monitor->update($input);
}
}
if (isset($_SESSION['plugin_fusioninventory_rules_id'])) {
$pfRulematchedlog = new PluginFusioninventoryRulematchedlog();
$inputrulelog = [];
$inputrulelog['date'] = date('Y-m-d H:i:s');
$inputrulelog['rules_id'] = $_SESSION['plugin_fusioninventory_rules_id'];
if (isset($_SESSION['plugin_fusioninventory_agents_id'])) {
$inputrulelog['plugin_fusioninventory_agents_id'] =
$_SESSION['plugin_fusioninventory_agents_id'];
}
$inputrulelog['items_id'] = end($a_monitors);
$inputrulelog['itemtype'] = "Monitor";
$inputrulelog['method'] = 'inventory';
$pfRulematchedlog->add($inputrulelog, [], false);
$pfRulematchedlog->cleanOlddata(end($a_monitors), "Monitor");
unset($_SESSION['plugin_fusioninventory_rules_id']);
}
}
}
$db_monitors = [];
$iterator = $DB->request([
'SELECT' => [
'glpi_monitors.id',
'glpi_computers_items.id AS link_id'
],
'FROM' => 'glpi_computers_items',
'LEFT JOIN' => [
'glpi_monitors' => [
'FKEY' => [
'glpi_monitors' => 'id',
'glpi_computers_items' => 'items_id'
]
]
],
'WHERE' => [
'itemtype' => 'Monitor',
'computers_id' => $computers_id,
'entities_id' => $entities_id,
'glpi_computers_items.is_dynamic' => 1,
'glpi_monitors.is_global' => 0
]
]);
foreach ($iterator as $data) {
$idtmp = $data['link_id'];
unset($data['link_id']);
$db_monitors[$idtmp] = $data['id'];
}
if (count($db_monitors) == 0) {
foreach ($a_monitors as $monitors_id) {
$input = [
'computers_id' => $computers_id,
'itemtype' => 'Monitor',
'items_id' => $monitors_id,
'is_dynamic' => 1,
'_no_history' => $no_history
];
$this->computerItemAdd($input, $no_history);
}
} else {
// Check all fields from source:
foreach ($a_monitors as $key => $monitors_id) {
foreach ($db_monitors as $keydb => $monits_id) {
if ($monitors_id == $monits_id) {
unset($a_monitors[$key]);
unset($db_monitors[$keydb]);
break;
}
}
}
if (count($a_monitors) || count($db_monitors)) {
if (count($db_monitors) != 0) {
// Delete monitors links in DB
foreach ($db_monitors as $idtmp => $monits_id) {
$computer_Item->delete(['id'=>$idtmp], 1);
}
}
if (count($a_monitors) != 0) {
foreach ($a_monitors as $key => $monitors_id) {
$input = [];
$input['computers_id'] = $computers_id;
$input['itemtype'] = 'Monitor';
$input['items_id'] = $monitors_id;
$input['is_dynamic'] = 1;
$input['_no_history'] = $no_history;
$this->computerItemAdd($input, $no_history);
}
}
}
}
}
// * Printers
if ($importExternalDevices) {
$rule = new PluginFusioninventoryInventoryRuleImportCollection();
$a_printers = [];
foreach ($a_computerinventory['printer'] as $key => $arrays) {
$input = [];
$input['itemtype'] = "Printer";
$input['name'] = $arrays['name'];
$input['serial'] = isset($arrays['serial'])
? $arrays['serial']
: "";
$data = $rule->processAllRules($input, [], ['class'=>$this, 'return' => true]);
if (isset($data['found_equipment'])) {
if ($data['found_equipment'][0] == 0) {
// add printer
$arrays['entities_id'] = $entities_id;
$arrays['otherserial'] = PluginFusioninventoryToolbox::setInventoryNumber(
'Printer', '', $entities_id);
$a_printers[] = $printer->add($arrays);
} else {
$a_printers[] = $data['found_equipment'][0];
}
if (isset($_SESSION['plugin_fusioninventory_rules_id'])) {
$pfRulematchedlog = new PluginFusioninventoryRulematchedlog();
$inputrulelog = [];
$inputrulelog['date'] = date('Y-m-d H:i:s');
$inputrulelog['rules_id'] = $_SESSION['plugin_fusioninventory_rules_id'];
if (isset($_SESSION['plugin_fusioninventory_agents_id'])) {
$inputrulelog['plugin_fusioninventory_agents_id'] =
$_SESSION['plugin_fusioninventory_agents_id'];
}
$inputrulelog['items_id'] = end($a_printers);
$inputrulelog['itemtype'] = "Printer";
$inputrulelog['method'] = 'inventory';
$pfRulematchedlog->add($inputrulelog, [], false);
$pfRulematchedlog->cleanOlddata(end($a_printers), "Printer");
unset($_SESSION['plugin_fusioninventory_rules_id']);
}
}
}
$db_printers = [];
$iterator = $DB->request([
'SELECT' => [
'glpi_printers.id',
'glpi_computers_items.id AS link_id'
],
'FROM' => 'glpi_computers_items',
'LEFT JOIN' => [
'glpi_printers' => [
'FKEY' => [
'glpi_printers' => 'id',
'glpi_computers_items' => 'items_id'
]
]
],
'WHERE' => [
'itemtype' => 'Printer',
'computers_id' => $computers_id,
'entities_id' => $entities_id,
'glpi_computers_items.is_dynamic' => 1,
'glpi_printers.is_global' => 0
]
]);
foreach ($iterator as $data) {
$idtmp = $data['link_id'];
unset($data['link_id']);
$db_printers[$idtmp] = $data['id'];
}
if (count($db_printers) == 0) {
foreach ($a_printers as $printers_id) {
$input['entities_id'] = $entities_id;
$input['computers_id'] = $computers_id;
$input['itemtype'] = 'Printer';
$input['items_id'] = $printers_id;
$input['is_dynamic'] = 1;
$input['_no_history'] = $no_history;
$this->computerItemAdd($input, $no_history);
}
} else {
// Check all fields from source:
foreach ($a_printers as $key => $printers_id) {
foreach ($db_printers as $keydb => $prints_id) {
if ($printers_id == $prints_id) {
unset($a_printers[$key]);
unset($db_printers[$keydb]);
break;
}
}
}
if (count($a_printers) || count($db_printers)) {
if (count($db_printers) != 0) {
// Delete printers links in DB
foreach ($db_printers as $idtmp => $data) {
$computer_Item->delete(['id'=>$idtmp], 1);
}
}
if (count($a_printers) != 0) {
foreach ($a_printers as $printers_id) {
$input['entities_id'] = $entities_id;
$input['computers_id'] = $computers_id;
$input['itemtype'] = 'Printer';
$input['items_id'] = $printers_id;
$input['is_dynamic'] = 1;
$input['_no_history'] = $no_history;
$this->computerItemAdd($input, $no_history);
}
}
}
}
}
// * Peripheral
if ($importExternalDevices) {
$rule = new PluginFusioninventoryInventoryRuleImportCollection();
$a_peripherals = [];
foreach ($a_computerinventory['peripheral'] as $key => $arrays) {
$input = [];
$input['itemtype'] = "Peripheral";
$input['name'] = $arrays['name'];
$input['serial'] = isset($arrays['serial'])
? $arrays['serial']
: "";
$data = $rule->processAllRules($input, [], ['class'=>$this, 'return' => true]);
if (isset($data['found_equipment'])) {
if ($data['found_equipment'][0] == 0) {
// add peripheral
$arrays['entities_id'] = $entities_id;
$arrays['otherserial'] = PluginFusioninventoryToolbox::setInventoryNumber(
'Peripheral', '', $entities_id);
$a_peripherals[] = $peripheral->add($arrays);
} else {
$a_peripherals[] = $data['found_equipment'][0];
}
if (isset($_SESSION['plugin_fusioninventory_rules_id'])) {
$pfRulematchedlog = new PluginFusioninventoryRulematchedlog();
$inputrulelog = [];
$inputrulelog['date'] = date('Y-m-d H:i:s');
$inputrulelog['rules_id'] = $_SESSION['plugin_fusioninventory_rules_id'];
if (isset($_SESSION['plugin_fusioninventory_agents_id'])) {
$inputrulelog['plugin_fusioninventory_agents_id'] =
$_SESSION['plugin_fusioninventory_agents_id'];
}
$inputrulelog['items_id'] = end($a_peripherals);
$inputrulelog['itemtype'] = "Peripheral";
$inputrulelog['method'] = 'inventory';
$pfRulematchedlog->add($inputrulelog, [], false);
$pfRulematchedlog->cleanOlddata(end($a_peripherals), "Peripheral");
unset($_SESSION['plugin_fusioninventory_rules_id']);
}
}
}
$db_peripherals = [];
$iterator = $DB->request([
'SELECT' => [
'glpi_peripherals.id',
'glpi_computers_items.id AS link_id'
],
'FROM' => 'glpi_computers_items',
'LEFT JOIN' => [
'glpi_peripherals' => [
'FKEY' => [
'glpi_peripherals' => 'id',
'glpi_computers_items' => 'items_id'
]
]
],
'WHERE' => [
'itemtype' => 'Peripheral',
'computers_id' => $computers_id,
'entities_id' => $entities_id,
'glpi_computers_items.is_dynamic' => 1,
'glpi_peripherals.is_global' => 0
]
]);
foreach ($iterator as $data) {
$idtmp = $data['link_id'];
unset($data['link_id']);
$db_peripherals[$idtmp] = $data['id'];
}
if (count($db_peripherals) == 0) {
foreach ($a_peripherals as $peripherals_id) {
$input = [];
$input['computers_id'] = $computers_id;
$input['itemtype'] = 'Peripheral';
$input['items_id'] = $peripherals_id;
$input['is_dynamic'] = 1;
$input['_no_history'] = $no_history;
$this->computerItemAdd($input, $no_history);
}
} else {
// Check all fields from source:
foreach ($a_peripherals as $key => $peripherals_id) {
foreach ($db_peripherals as $keydb => $periphs_id) {
if ($peripherals_id == $periphs_id) {
unset($a_peripherals[$key]);
unset($db_peripherals[$keydb]);
break;
}
}
}
if (count($a_peripherals) || count($db_peripherals)) {
if (count($db_peripherals) != 0) {
// Delete peripherals links in DB
foreach ($db_peripherals as $idtmp => $data) {
$computer_Item->delete(['id'=>$idtmp], 1);
}
}
if (count($a_peripherals) != 0) {
foreach ($a_peripherals as $peripherals_id) {
$input = [];
$input['computers_id'] = $computers_id;
$input['itemtype'] = 'Peripheral';
$input['items_id'] = $peripherals_id;
$input['is_dynamic'] = 1;
$input['_no_history'] = $no_history;
$this->computerItemAdd($input, $no_history);
}
}
}
}
}
// * storage
// Manage by uuid to correspond with GLPI data
// $db_storage = array();
// if ($no_history === FALSE) {
// $query = "SELECT `id`, `uuid` FROM ".
// "`glpi_plugin_fusioninventory_inventorycomputerstorages`
// WHERE `computers_id` = '$computers_id'";
// $result = $DB->query($query);
// while ($data = $DB->fetchAssoc($result)) {
// $idtmp = $data['id'];
// unset($data['id']);
// $data = Toolbox::addslashes_deep($data);
// $data = array_map('strtolower', $data);
// $db_storage[$idtmp] = $data;
// }
// }
// if (count($db_storage) == 0) {
// $a_links = array();
// $a_uuid = array();
// foreach ($a_computerinventory['storage'] as $a_storage) {
// $a_storage['computers_id'] = $computers_id;
// $insert_id = $pfInventoryComputerStorage->add($a_storage);
// if (isset($a_storage['uuid'])) {
// $a_uuid[$a_storage['uuid']] = $insert_id;
// if (isset($a_storage['uuid_link'])) {
// if (is_array($a_storage['uuid_link'])) {
// $a_links[$insert_id] = $a_storage['uuid_link'];
// } else {
// $a_links[$insert_id][] = $a_storage['uuid_link'];
// }
// }
// }
// }
// foreach ($a_links as $id=>$data) {
// foreach ($data as $num=>$uuid) {
// $a_links[$id][$num] = $a_uuid[$uuid];
// }
// }
// foreach ($a_links as $id=>$data) {
// foreach ($data as $id2) {
// $input = array();
// $input['plugin_fusioninventory_inventorycomputerstorages_id_1'] = $id;
// $input['plugin_fusioninventory_inventorycomputerstorages_id_2'] = $id2;
// $pfInventoryComputerStorage_Storage->add($input);
// }
// }
// } else {
// // Check only field *** from source:
//
// }
Plugin::doHook("fusioninventory_inventory",
['inventory_data' => $a_computerinventory,
'computers_id' => $computers_id,
'no_history' => $no_history
]);
$this->addLog();
}
/**
* Manage network ports
*
* @global object $DB
* @param array $inventory_networkports
* @param integer $computers_id
* @param boolean $no_history
*/
function manageNetworkPort($inventory_networkports, $computers_id, $no_history) {
global $DB;
$networkPort = new NetworkPort();
$networkName = new NetworkName();
$iPAddress = new IPAddress();
$iPNetwork = new IPNetwork();
$item_DeviceNetworkCard = new Item_DeviceNetworkCard();
foreach ($inventory_networkports as $a_networkport) {
if ($a_networkport['mac'] != '') {
$a_networkports = $networkPort->find(
['mac' => $a_networkport['mac'],
'itemtype' => 'PluginFusioninventoryUnmanaged'],
[], 1);
if (count($a_networkports) > 0) {
$input = current($a_networkports);
$unmanageds_id = $input['items_id'];
$input['logical_number'] = $a_networkport['logical_number'];
$input['itemtype'] = 'Computer';
$input['items_id'] = $computers_id;
$input['is_dynamic'] = 1;
$input['name'] = $a_networkport['name'];
$networkPort->update($input, !$no_history);
$pfUnmanaged = new PluginFusioninventoryUnmanaged();
$pfUnmanaged->delete(['id'=>$unmanageds_id], 1);
}
}
}
// end get port from unknown device
$db_networkport = [];
$iterator = $DB->request([
'SELECT' => ['id', 'name', 'mac', 'instantiation_type', 'logical_number'],
'FROM' => 'glpi_networkports',
'WHERE' => [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'is_dynamic' => 1
]
]);
foreach ($iterator as $data) {
$idtmp = $data['id'];
unset($data['id']);
if (is_null($data['mac'])) {
$data['mac'] = '';
}
if (preg_match("/[^a-zA-Z0-9 \-_\(\)]+/", $data['name'])) {
$data['name'] = Toolbox::addslashes_deep($data['name']);
}
$db_networkport[$idtmp] = array_map('strtolower', $data);
}
$simplenetworkport = [];
foreach ($inventory_networkports as $key=>$a_networkport) {
// Add ipnetwork if not exist
if ($a_networkport['gateway'] != ''
&& $a_networkport['netmask'] != ''
&& $a_networkport['subnet'] != '') {
if (countElementsInTable('glpi_ipnetworks',
[
'address' => $a_networkport['subnet'],
'netmask' => $a_networkport['netmask'],
'gateway' => $a_networkport['gateway'],
'entities_id' => $_SESSION["plugin_fusioninventory_entity"],
]) == 0) {
$input_ipanetwork = [
'name' => $a_networkport['subnet'].'/'.
$a_networkport['netmask'].' - '.
$a_networkport['gateway'],
'network' => $a_networkport['subnet'].' / '.
$a_networkport['netmask'],
'gateway' => $a_networkport['gateway'],
'entities_id' => $_SESSION["plugin_fusioninventory_entity"]
];
$iPNetwork->add($input_ipanetwork, [], !$no_history);
}
}
// End add ipnetwork
$a_field = ['name', 'mac', 'instantiation_type'];
foreach ($a_field as $field) {
if (isset($a_networkport[$field])) {
$simplenetworkport[$key][$field] = $a_networkport[$field];
}
}
}
foreach ($simplenetworkport as $key => $arrays) {
$arrayslower = array_map('strtolower', $arrays);
foreach ($db_networkport as $keydb => $arraydb) {
$logical_number = $arraydb['logical_number'];
unset($arraydb['logical_number']);
if ($arrayslower == $arraydb) {
if ($inventory_networkports[$key]['logical_number'] != $logical_number) {
$input = [];
$input['id'] = $keydb;
$input['logical_number'] = $inventory_networkports[$key]['logical_number'];
$networkPort->update($input, !$no_history);
}
// Add / update instantiation_type
if (isset($inventory_networkports[$key]['instantiation_type'])) {
$instantiation_type = $inventory_networkports[$key]['instantiation_type'];
if (in_array($instantiation_type, ['NetworkPortEthernet',
'NetworkPortFiberchannel'])) {
$instance = new $instantiation_type;
$portsinstance = $instance->find(['networkports_id' => $keydb], [], 1);
if (count($portsinstance) == 1) {
$portinstance = current($portsinstance);
$input = $portinstance;
} else {
$input = [
'networkports_id' => $keydb
];
}
if (isset($inventory_networkports[$key]['speed'])) {
$input['speed'] = $inventory_networkports[$key]['speed'];
$input['speed_other_value'] = $inventory_networkports[$key]['speed'];
}
if (isset($inventory_networkports[$key]['wwn'])) {
$input['wwn'] = $inventory_networkports[$key]['wwn'];
}
if (isset($inventory_networkports[$key]['mac'])) {
$networkcards = $item_DeviceNetworkCard->find(
['mac' => $inventory_networkports[$key]['mac'],
'itemtype' => 'Computer',
'items_id' => $computers_id],
[], 1);
if (count($networkcards) == 1) {
$networkcard = current($networkcards);
$input['items_devicenetworkcards_id'] = $networkcard['id'];
}
}
$input['_no_history'] = $no_history;
if (isset($input['id'])) {
$instance->update($input);
} else {
$instance->add($input);
}
}
}
// Get networkname
$a_networknames_find = current($networkName->find(
['items_id' => $keydb,
'itemtype' => 'NetworkPort'],
[], 1));
if (!isset($a_networknames_find['id'])) {
$a_networkport['entities_id'] = $_SESSION["plugin_fusioninventory_entity"];
$a_networkport['items_id'] = $computers_id;
$a_networkport['itemtype'] = "Computer";
$a_networkport['is_dynamic'] = 1;
$a_networkport['_no_history'] = $no_history;
$a_networkport['items_id'] = $keydb;
unset($a_networkport['_no_history']);
$a_networkport['is_recursive'] = 0;
$a_networkport['itemtype'] = 'NetworkPort';
unset($a_networkport['name']);
$a_networkport['_no_history'] = $no_history;
$a_networknames_id = $networkName->add($a_networkport, [], !$no_history);
$a_networknames_find['id'] = $a_networknames_id;
}
// Same networkport, verify ipaddresses
$db_addresses = [];
$iterator = $DB->request([
'SELECT' => ['id', 'name'],
'FROM' => 'glpi_ipaddresses',
'WHERE' => [
'items_id' => $a_networknames_find['id'],
'itemtype' => 'NetworkName'
]
]);
foreach ($iterator as $data) {
$db_addresses[$data['id']] = $data['name'];
}
$a_computerinventory_ipaddress =
$inventory_networkports[$key]['ipaddress'];
$nb_ip = count($a_computerinventory_ipaddress);
foreach ($a_computerinventory_ipaddress as $key2 => $arrays2) {
foreach ($db_addresses as $keydb2 => $arraydb2) {
if ($arrays2 == $arraydb2) {
unset($a_computerinventory_ipaddress[$key2]);
unset($db_addresses[$keydb2]);
break;
}
}
}
if (count($a_computerinventory_ipaddress) || count($db_addresses)) {
if (count($db_addresses) != 0 AND $nb_ip > 0) {
// Delete ip address in DB
foreach (array_keys($db_addresses) as $idtmp) {
$iPAddress->delete(['id'=>$idtmp], 1);
}
}
if (count($a_computerinventory_ipaddress) != 0) {
foreach ($a_computerinventory_ipaddress as $ip) {
$input = [];
$input['items_id'] = $a_networknames_find['id'];
$input['itemtype'] = 'NetworkName';
$input['name'] = $ip;
$input['is_dynamic'] = 1;
$iPAddress->add($input, [], !$no_history);
}
}
}
unset($db_networkport[$keydb]);
unset($simplenetworkport[$key]);
unset($inventory_networkports[$key]);
break;
}
}
}
if (count($inventory_networkports) == 0
AND count($db_networkport) == 0) {
// Nothing to do
$coding_std = true;
} else {
if (count($db_networkport) != 0) {
// Delete networkport in DB
foreach ($db_networkport as $idtmp => $data) {
$networkPort->delete(['id'=>$idtmp], 1);
}
}
if (count($inventory_networkports) != 0) {
foreach ($inventory_networkports as $a_networkport) {
$a_networkport['entities_id'] = $_SESSION["plugin_fusioninventory_entity"];
$a_networkport['items_id'] = $computers_id;
$a_networkport['itemtype'] = "Computer";
$a_networkport['is_dynamic'] = 1;
$a_networkport['_no_history'] = $no_history;
$a_networkport['items_id'] = $networkPort->add($a_networkport, [], !$no_history);
unset($a_networkport['_no_history']);
$a_networkport['is_recursive'] = 0;
$a_networkport['itemtype'] = 'NetworkPort';
unset($a_networkport['name']);
$a_networkport['_no_history'] = $no_history;
$a_networknames_id = $networkName->add($a_networkport, [], !$no_history);
foreach ($a_networkport['ipaddress'] as $ip) {
$input = [];
$input['items_id'] = $a_networknames_id;
$input['itemtype'] = 'NetworkName';
$input['name'] = $ip;
$input['is_dynamic'] = 1;
$input['_no_history'] = $no_history;
$iPAddress->add($input, [], !$no_history);
}
if (isset($a_networkport['instantiation_type'])) {
$instantiation_type = $a_networkport['instantiation_type'];
if (in_array($instantiation_type, ['NetworkPortEthernet',
'NetworkPortFiberchannel'])) {
$instance = new $instantiation_type;
$input = [
'networkports_id' => $a_networkport['items_id']
];
if (isset($a_networkport['speed'])) {
$input['speed'] = $a_networkport['speed'];
$input['speed_other_value'] = $a_networkport['speed'];
}
if (isset($a_networkport['wwn'])) {
$input['wwn'] = $a_networkport['wwn'];
}
if (isset($a_networkport['mac'])) {
$networkcards = $item_DeviceNetworkCard->find(
['mac' => $a_networkport['mac'],
'itemtype' => 'Computer',
'items_id' => $computers_id],
[], 1);
if (count($networkcards) == 1) {
$networkcard = current($networkcards);
$input['items_devicenetworkcards_id'] = $networkcard['id'];
}
}
$input['_no_history'] = $no_history;
$instance->add($input);
}
}
}
}
}
}
/**
* Add a new domain
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addDomain($domains_id, $computers_id, $no_history) {
$domain_Item = new Domain_Item();
$data = [
'items_id' => $computers_id,
'itemtype' => 'Computer',
'domains_id' => $domains_id
];
$domain_Item->add($data, [], !$no_history);
}
/**
* Add a new bios component
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addBios($data, $computers_id, $no_history) {
$item_DeviceBios = new Item_DeviceFirmware();
$deviceBios = new DeviceFirmware();
$fwTypes = new DeviceFirmwareType();
$fwTypes->getFromDBByCrit([
'name' => 'BIOS'
]);
$type_id = $fwTypes->getID();
$data['devicefirmwaretypes_id'] = $type_id;
$bios_id = $deviceBios->import($data);
$data['devicefirmwares_id'] = $bios_id;
$data['itemtype'] = 'Computer';
$data['items_id'] = $computers_id;
$data['is_dynamic'] = 1;
$data['_no_history'] = $no_history;
$item_DeviceBios->add($data, [], !$no_history);
}
/**
* Add a new processor component
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addProcessor($data, $computers_id, $no_history) {
$item_DeviceProcessor = new Item_DeviceProcessor();
$deviceProcessor = new DeviceProcessor();
$processors_id = $deviceProcessor->import($data);
$data['deviceprocessors_id'] = $processors_id;
$data['itemtype'] = 'Computer';
$data['items_id'] = $computers_id;
$data['is_dynamic'] = 1;
$data['_no_history'] = $no_history;
$item_DeviceProcessor->add($data, [], !$no_history);
}
/**
* Add a new memory component
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addMemory($data, $computers_id, $no_history) {
$item_DeviceMemory = new Item_DeviceMemory();
$deviceMemory = new DeviceMemory();
$memories_id = $deviceMemory->import($data);
$data['devicememories_id'] = $memories_id;
$data['itemtype'] = 'Computer';
$data['items_id'] = $computers_id;
$data['is_dynamic'] = 1;
$data['_no_history'] = $no_history;
$item_DeviceMemory->add($data, [], !$no_history);
}
/**
* Add a new hard disk component
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addHardDisk($data, $computers_id, $no_history) {
$item_DeviceHardDrive = new Item_DeviceHardDrive();
$deviceHardDrive = new DeviceHardDrive();
$harddrives_id = $deviceHardDrive->import($data);
$data['deviceharddrives_id'] = $harddrives_id;
$data['itemtype'] = 'Computer';
$data['items_id'] = $computers_id;
$data['is_dynamic'] = 1;
$data['_no_history'] = $no_history;
$item_DeviceHardDrive->add($data, [], !$no_history);
}
/**
* Add a new drive component
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addDrive($data, $computers_id, $no_history) {
$item_DeviceDrive = new Item_DeviceDrive();
$deviceDrive = new DeviceDrive();
$drives_id = $deviceDrive->import($data);
$data['devicedrives_id'] = $drives_id;
$data['itemtype'] = 'Computer';
$data['items_id'] = $computers_id;
$data['is_dynamic'] = 1;
$data['_no_history'] = $no_history;
$item_DeviceDrive->add($data, [], !$no_history);
}
/**
* Add a new graphic card component
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addGraphicCard($data, $computers_id, $no_history) {
$item_DeviceGraphicCard = new Item_DeviceGraphicCard();
$deviceGraphicCard = new DeviceGraphicCard();
$graphiccards_id = $deviceGraphicCard->import($data);
$data['devicegraphiccards_id'] = $graphiccards_id;
$data['itemtype'] = 'Computer';
$data['items_id'] = $computers_id;
$data['is_dynamic'] = 1;
$data['_no_history'] = $no_history;
$item_DeviceGraphicCard->add($data, [], !$no_history);
}
/**
* Add a new network card component
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addNetworkCard($data, $computers_id, $no_history) {
$item_DeviceNetworkCard = new Item_DeviceNetworkCard();
$deviceNetworkCard = new DeviceNetworkCard();
$networkcards_id = $deviceNetworkCard->add($data);
$data['devicenetworkcards_id'] = $networkcards_id;
$data['itemtype'] = 'Computer';
$data['items_id'] = $computers_id;
$data['is_dynamic'] = 1;
$data['_no_history'] = $no_history;
$item_DeviceNetworkCard->add($data, [], !$no_history);
}
/**
* Add a new sound card component
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addSoundCard($data, $computers_id, $no_history) {
$item_DeviceSoundCard = new Item_DeviceSoundCard();
$deviceSoundCard = new DeviceSoundCard();
$sounds_id = $deviceSoundCard->import($data);
$data['devicesoundcards_id'] = $sounds_id;
$data['itemtype'] = 'Computer';
$data['items_id'] = $computers_id;
$data['is_dynamic'] = 1;
$data['_no_history'] = $no_history;
$item_DeviceSoundCard->add($data, [], !$no_history);
}
/**
* Add a new controller component
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addControl($data, $computers_id, $no_history) {
$item_DeviceControl = new Item_DeviceControl();
$deviceControl = new DeviceControl();
$controllers_id = $deviceControl->import($data);
$data['devicecontrols_id'] = $controllers_id;
$data['itemtype'] = 'Computer';
$data['items_id'] = $computers_id;
$data['is_dynamic'] = 1;
$data['_no_history'] = $no_history;
$item_DeviceControl->add($data, [], !$no_history);
}
/**
* Add a new battery component
*
* @param array $data
* @param integer $computers_id
* @param boolean $no_history
*/
function addBattery($data, $computers_id, $no_history) {
$item_DeviceBattery = new Item_DeviceBattery();
$deviceBattery = new DeviceBattery();
if (!isset($data['voltage']) || $data['voltage'] == '') {
//a numeric value is expected here
$data['voltage'] = 0;
}
if (empty($data['designation'])) {
//Placebo designation; sometimes missing from agent
$data['designation'] = __('Internal battery', 'fusioninventory');
}
$batteries_id = $deviceBattery->import($data);
$data['devicebatteries_id'] = $batteries_id;
$data['itemtype'] = 'Computer';
$data['items_id'] = $computers_id;
$data['is_dynamic'] = 1;
$data['_no_history'] = $no_history;
$item_DeviceBattery->add($data, [], !$no_history);
}
/**
* Add a new cron task
*
* @param array $data
* @param boolean $no_history
*/
function addFusionInventoryCronTask($data, $no_history) {
$cronTask = new PluginFusioninventoryCronTask();
$cronTask->add($data, [], !$no_history);
}
/**
* Returns glpi user id if found or 0
*
* @param $DB
* @param $user
* @return int
*/
function retrieveFusionInventoryCronTaskUserId($DB, $user) {
$query = "SELECT `id`
FROM `glpi_users`
WHERE `name` = '" . $user . "'
LIMIT 1";
$result = $DB->query($query);
return $DB->numrows($result) == 1 ? $DB->result($result, 0, 0) : 0;
}
/**
* Load softwares from database that are matching softwares coming from the
* currently processed inventory
*
* @global object $DB
* @param integer $entities_id entitity id
* @param array $a_soft list of software from the agent inventory
* @param integer $lastid last id search to not search from beginning
* @return integer last software id
*/
function loadSoftwares($entities_id, $a_soft, $lastid = 0) {
global $DB;
$whereid = '';
if ($lastid > 0) {
$whereid .= ' AND `id` > "'.$lastid.'"';
}
$a_softSearch = [];
$nbSoft = 0;
if (count($this->softList) == 0) {
foreach ($a_soft as $a_software) {
$a_softSearch[] = "'".$a_software['name']."$$$$".$a_software['manufacturers_id']."'";
$nbSoft++;
}
} else {
foreach ($a_soft as $a_software) {
if (!isset($this->softList[$a_software['name']."$$$$".$a_software['manufacturers_id']])) {
$a_softSearch[] = "'".$a_software['name']."$$$$".$a_software['manufacturers_id']."'";
$nbSoft++;
}
}
}
$whereid .= " AND CONCAT_WS('$$$$', `name`, `manufacturers_id`) IN (".implode(",", $a_softSearch).")";
$sql = "SELECT max( id ) AS max FROM `glpi_softwares`";
$result = $DB->query($sql);
$data = $DB->fetchAssoc($result);
$lastid = $data['max'];
$whereid.= " AND `id` <= '".$lastid."'";
if ($nbSoft == 0) {
return $lastid;
}
$sql = "SELECT `id`, `name`, `manufacturers_id`
FROM `glpi_softwares`
WHERE `entities_id`='".$entities_id."'".$whereid;
foreach ($DB->request($sql) as $data) {
$this->softList[Toolbox::addslashes_deep($data['name'])."$$$$".$data['manufacturers_id']] = $data['id'];
}
return $lastid;
}
/**
* Load software versions from DB are in the incomming inventory
*
* @global object $DB
* @param integer $entities_id entitity id
* @param array $a_softVersion list of software versions from the agent inventory
* @param integer $lastid last id search to not search from beginning
* @return integer last software version id
*/
function loadSoftwareVersions($entities_id, $a_softVersion, $lastid = 0) {
global $DB;
$whereid = '';
if ($lastid > 0) {
$whereid .= ' AND `id` > "'.$lastid.'"';
}
$arr = [];
$a_versions = [];
foreach ($a_softVersion as $a_software) {
$softwares_id = $this->softList[$a_software['name']."$$$$".$a_software['manufacturers_id']];
if (!isset($this->softVersionList[strtolower($a_software['version'])."$$$$".$softwares_id."$$$$".$a_software['operatingsystems_id']])) {
$a_versions[$a_software['version']][] = $softwares_id;
}
}
$nbVersions = 0;
foreach ($a_versions as $name=>$a_softwares_id) {
foreach ($a_softwares_id as $softwares_id) {
$arr[] = "'".$name."$$$$".$softwares_id."$$$$".$a_software['operatingsystems_id']."'";
}
$nbVersions++;
}
$whereid .= " AND CONCAT_WS('$$$$', `name`, `softwares_id`, `operatingsystems_id`) IN ( ";
$whereid .= implode(',', $arr);
$whereid .= " ) ";
$sql = "SELECT max( id ) AS max FROM `glpi_softwareversions`";
$result = $DB->query($sql);
$data = $DB->fetchAssoc($result);
$lastid = $data['max'];
$whereid .= " AND `id` <= '".$lastid."'";
if ($nbVersions == 0) {
return $lastid;
}
$sql = "SELECT `id`, `name`, `softwares_id`, `operatingsystems_id` FROM `glpi_softwareversions`
WHERE `entities_id`='".$entities_id."'".$whereid;
$result = $DB->query($sql);
while ($data = $DB->fetchAssoc($result)) {
$this->softVersionList[strtolower($data['name'])."$$$$".$data['softwares_id']."$$$$".$data['operatingsystems_id']] = $data['id'];
}
return $lastid;
}
/**
* Add a new software
*
* @param array $a_software
* @param array $options
*/
function addSoftware($a_software, $options) {
$a_softwares_id = $this->software->add($a_software, $options, false);
$this->addPrepareLog($a_softwares_id, 'Software');
$this->softList[$a_software['name']."$$$$".$a_software['manufacturers_id']] = $a_softwares_id;
}
/**
* Add a software version
*
* @param array $a_software
* @param integer $softwares_id
* @param boolean $no_history
*/
function addSoftwareVersion($a_software, $softwares_id, $no_history) {
$options = [];
$options['disable_unicity_check'] = true;
$a_software['name'] = $a_software['version'];
$a_software['softwares_id'] = $softwares_id;
$a_software['_no_history'] = true;
$softwareversions_id = $this->softwareVersion->add($a_software, $options, false);
$this->addPrepareLog($softwareversions_id, 'SoftwareVersion');
$this->softVersionList[strtolower($a_software['version'])."$$$$".$softwares_id."$$$$".$a_software['operatingsystems_id']] = $softwareversions_id;
}
/**
* Link software versions with the computer
*
* @global object $DB
* @param array $a_input
*/
function addSoftwareVersionsComputer($a_input) {
global $DB;
$insert_query = $DB->buildInsert(
'glpi_items_softwareversions', [
'itemtype' => 'Computer',
'items_id' => new \QueryParam(),
'softwareversions_id' => new \QueryParam(),
'is_dynamic' => new \QueryParam(),
'entities_id' => new \QueryParam(),
'date_install' => new \QueryParam()
]
);
$stmt = $DB->prepare($insert_query);
foreach ($a_input as $input) {
$stmt->bind_param(
'sssss',
$input['items_id'],
$input['softwareversions_id'],
$input['is_dynamic'],
$input['entities_id'],
$input['date_install']
);
$ret = $stmt->execute();
if (!$ret) {
trigger_error($stmt->error, E_USER_ERROR);
}
}
mysqli_stmt_close($stmt);
}
/**
* Link software version with the computer
*
* @param array $a_software
* @param integer $computers_id
* @param boolean $no_history
* @param array $options
*/
function addSoftwareVersionComputer($a_software, $computers_id, $no_history, $options) {
$options['disable_unicity_check'] = true;
$softwares_id = $this->softList[$a_software['name']."$$$$".$a_software['manufacturers_id']];
$softwareversions_id = $this->softVersionList[strtolower($a_software['version'])."$$$$".$softwares_id."$$$$".$a_software['operatingsystems_id']];
$this->softwareVersion->getFromDB($softwareversions_id);
$a_software['itemtype'] = 'Computer';
$a_software['items_id'] = $computers_id;
$a_software['softwareversions_id'] = $softwareversions_id;
$a_software['is_dynamic'] = 1;
$a_software['is_template_item'] = false;
$a_software['is_deleted_item'] = false;
$a_software['_no_history'] = true;
$a_software['entities_id'] = $computers_id['entities_id'];
//Check if historical has been disabled for this software only
$comp_key = strtolower($a_software['name']).
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.strtolower($a_software['version']).
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['manufacturers_id'].
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['entities_id'].
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['operatingsystems_id'];
if (isset($a_software['no_history']) && $a_software['no_history']) {
$no_history_for_this_software = true;
} else {
$no_history_for_this_software = false;
}
if ($this->computerSoftwareVersion->add($a_software, $options, false)) {
if (!$no_history && !$no_history_for_this_software) {
$changes[0] = '0';
$changes[1] = "";
$changes[2] = addslashes($this->computerSoftwareVersion->getHistoryNameForItem1($this->softwareVersion, 'add'));
$this->addPrepareLog($computers_id, 'Computer', 'SoftwareVersion', $changes,
Log::HISTORY_INSTALL_SOFTWARE);
$changes[0] = '0';
$changes[1] = "";
$changes[2] = addslashes($this->computerSoftwareVersion->getHistoryNameForItem2($this->computer, 'add'));
$this->addPrepareLog($softwareversions_id, 'SoftwareVersion', 'Computer', $changes,
Log::HISTORY_INSTALL_SOFTWARE);
}
}
}
/**
* Arraydiff function to have real diff between 2 arrays
*
* @param array $arrayFrom
* @param array $arrayAgainst
* @return array
*/
function arrayDiffEmulation($arrayFrom, $arrayAgainst) {
$arrayAgainsttmp = [];
foreach ($arrayAgainst as $key => $data) {
$arrayAgainsttmp[serialize($data)] = $key;
}
foreach ($arrayFrom as $key => $value) {
if (isset($arrayAgainsttmp[serialize($value)])) {
unset($arrayFrom[$key]);
}
}
return $arrayFrom;
}
/**
* Prepare add history in database
*
* @param integer $items_id
* @param string $itemtype
* @param string $itemtype_link
* @param array $changes
* @param integer $linked_action
*/
function addPrepareLog($items_id, $itemtype, $itemtype_link = '', $changes = ['0', '', ''], $linked_action = Log::HISTORY_CREATE_ITEM) {
$this->log_add[] = [$items_id, $itemtype, $itemtype_link, $_SESSION["glpi_currenttime"], $changes, $linked_action];
}
/**
* Insert logs are in queue
*
* @global object $DB
*/
function addLog() {
global $DB;
if (count($this->log_add) > 0) {
$qparam = new \QueryParam();
$stmt = $DB->prepare(
$DB->buildInsert(
'glpi_logs', [
'items_id' => $qparam,
'itemtype' => $qparam,
'itemtype_link' => $qparam,
'date_mod' => $qparam,
'linked_action' => $qparam,
'id_search_option' => $qparam,
'old_value' => $qparam,
'new_value' => $qparam,
'user_name' => $qparam
]
)
);
$username = addslashes($_SESSION["glpiname"]);
foreach ($this->log_add as $data) {
$changes = $data[4];
unset($data[4]);
$data = array_values($data);
$id_search_option = $changes[0];
$old_value = $changes[1];
$new_value = $changes[2];
$stmt->bind_param(
'sssssssss',
$data[0],
$data[1],
$data[2],
$data[3],
$data[4],
$id_search_option,
$old_value,
$new_value,
$username
);
$ret = $stmt->execute();
if (!$ret) {
trigger_error($stmt->error, E_USER_ERROR);
}
}
$this->log_add = [];
}
}
/**
* Define items link to computer in dynamic mode
*
* @global object $DB
* @param integer $computers_id
*/
function setDynamicLinkItems($computers_id) {
global $DB;
$computer = new Computer();
$input = ['id' => $computers_id];
$input = PluginFusioninventoryToolbox::addDefaultStateIfNeeded('computer', $input);
$computer->update($input);
$a_tables = [
'glpi_computers_items',
'glpi_computervirtualmachines'
];
foreach ($a_tables as $table) {
$DB->update(
$table, [
'is_dynamic' => 1
], [
'computers_id' => $computers_id
]
);
}
$DB->update(
'glpi_items_softwareversions', [
'is_dynamic' => 1
], [
'itemtype' => 'Computer',
'items_id' => $computers_id
]
);
$a_tables = ["glpi_networkports", "glpi_items_devicecases", "glpi_items_devicecontrols",
"glpi_items_devicedrives", "glpi_items_devicegraphiccards",
"glpi_items_deviceharddrives", "glpi_items_devicememories",
"glpi_items_devicemotherboards", "glpi_items_devicenetworkcards",
"glpi_items_devicepcis", "glpi_items_devicepowersupplies",
"glpi_items_deviceprocessors", "glpi_items_devicesoundcards",
'glpi_items_disks'
];
foreach ($a_tables as $table) {
$DB->update(
$table, [
'is_dynamic' => 1,
], [
'itemtype' => 'Computer',
'items_id' => $computers_id
]
);
}
}
/**
* Import software
* @since 9.2+2.0
*
* @param string $itemtype the itemtype to be inventoried
* @param array $a_inventory Inventory data
* @param integer asset id
*
* @return void
*/
function importSoftware($itemtype, $a_inventory, $computer, $no_history) {
global $DB;
//By default entity = root
$entities_id = 0;
$computers_id = $computer->getID();
//Try to guess the entity of the software
if (count($a_inventory['software']) > 0) {
//Get the first software of the list
$a_softfirst = current($a_inventory['software']);
//Get the entity of the first software : this info has been processed
//in formatconvert, so it's either the computer's entity or
//the entity as defined in the entity's configuration
if (isset($a_softfirst['entities_id'])) {
$entities_id = $a_softfirst['entities_id'];
}
}
$db_software = [];
//If we must take care of historical : it means we're not :
//- at computer first inventory
//- during the first inventory after an OS upgrade/change
if ($no_history === false) {
$query = "SELECT `glpi_items_softwareversions`.`id` as sid,
`glpi_softwares`.`name`,
`glpi_softwareversions`.`name` AS version,
`glpi_softwares`.`manufacturers_id`,
`glpi_softwareversions`.`entities_id`,
`glpi_softwareversions`.`operatingsystems_id`,
`glpi_items_softwareversions`.`is_template_item`,
`glpi_items_softwareversions`.`is_deleted_item`
FROM `glpi_items_softwareversions`
LEFT JOIN `glpi_softwareversions`
ON (`glpi_items_softwareversions`.`softwareversions_id`
= `glpi_softwareversions`.`id`)
LEFT JOIN `glpi_softwares`
ON (`glpi_softwareversions`.`softwares_id` = `glpi_softwares`.`id`)
WHERE `glpi_items_softwareversions`.`items_id` = '$computers_id'
AND glpi_items_softwareversions.itemtype = 'Computer' AND `glpi_items_softwareversions`.`is_dynamic`='1'";
foreach ($DB->request($query) as $data) {
$idtmp = $data['sid'];
unset($data['sid']);
//Escape software name if needed
if (preg_match("/[^a-zA-Z0-9 \-_\(\)]+/", $data['name'])) {
$data['name'] = Toolbox::addslashes_deep($data['name']);
}
//Escape software version if needed
if (preg_match("/[^a-zA-Z0-9 \-_\(\)]+/", $data['version'])) {
$data['version'] = Toolbox::addslashes_deep($data['version']);
}
$comp_key = strtolower($data['name']).
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.strtolower($data['version']).
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$data['manufacturers_id'].
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$data['entities_id'].
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$data['operatingsystems_id'];
$db_software[$comp_key] = $idtmp;
}
}
$lastSoftwareid = 0;
$lastSoftwareVid = 0;
/*
* Schema
*
* LOCK software
* 1/ Add all software
* RELEASE software
*
* LOCK softwareversion
* 2/ Add all software versions
* RELEASE softwareversion
*
* 3/ add version to computer
*
*/
$dbLock = new PluginFusioninventoryDBLock();
if (count($db_software) == 0) { // there are no software associated with computer
$nb_unicity = count(FieldUnicity::getUnicityFieldsConfig("Software", $entities_id));
$options = [];
//There's no unicity rules, do not enable this feature
if ($nb_unicity == 0) {
$options['disable_unicity_check'] = true;
}
$lastSoftwareid = $this->loadSoftwares($entities_id,
$a_inventory['software'],
$lastSoftwareid);
//-----------------------------------
//Step 1 : import softwares
//-----------------------------------
//Put a lock during software import for this computer
$dbLock->setLock('softwares');
$this->loadSoftwares($entities_id,
$a_inventory['software'],
$lastSoftwareid);
//Browse softwares: add new software in database
foreach ($a_inventory['software'] as $a_software) {
if (!isset($this->softList[$a_software['name']."$$$$".
$a_software['manufacturers_id']])) {
$this->addSoftware($a_software, $options);
}
}
$dbLock->releaseLock('softwares');
//-----------------------------------
//Step 2 : import software versions
//-----------------------------------
$lastSoftwareVid = $this->loadSoftwareVersions($entities_id,
$a_inventory['software'],
$lastSoftwareVid);
$dbLock->setLock('softwareversions');
$this->loadSoftwareVersions($entities_id,
$a_inventory['software'],
$lastSoftwareVid);
foreach ($a_inventory['software'] as $a_software) {
$softwares_id = $this->softList[$a_software['name']
.PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['manufacturers_id']];
if (!isset($this->softVersionList[strtolower($a_software['version'])
.PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$softwares_id
.PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['operatingsystems_id']])) {
$this->addSoftwareVersion($a_software, $softwares_id, $no_history);
}
}
$dbLock->releaseLock('softwareversions');
$a_toinsert = [];
foreach ($a_inventory['software'] as $a_software) {
$softwares_id = $this->softList[$a_software['name']
.PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['manufacturers_id']];
$softwareversions_id = $this->softVersionList[strtolower($a_software['version'])
.PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$softwares_id
.PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['operatingsystems_id']];
$a_tmp = [
'itemtype' => 'Computer',
'items_id' => $computers_id,
'softwareversions_id' => $softwareversions_id,
'is_dynamic' => 1,
'entities_id' => $computer->fields['entities_id'],
'date_install' => null
];
//By default date_install is null: if an install date is provided,
//we set it
if (isset($a_software['date_install'])) {
$a_tmp['date_install'] = $a_software['date_install'];
}
$a_toinsert[] = $a_tmp;
}
if (count($a_toinsert) > 0) {
$this->addSoftwareVersionsComputer($a_toinsert);
//Check if historical has been disabled for this software only
$comp_key = strtolower($a_software['name']).
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.strtolower($a_software['version']).
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['manufacturers_id'].
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['entities_id'].
PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['operatingsystems_id'];
if (isset($a_software['no_history']) && $a_software['no_history']) {
$no_history_for_this_software = true;
} else {
$no_history_for_this_software = false;
}
if (!$no_history && !$no_history_for_this_software) {
foreach ($a_inventory['software'] as $a_software) {
$softwares_id = $this->softList[$a_software['name']
.PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['manufacturers_id']];
$softwareversions_id = $this->softVersionList[strtolower($a_software['version'])
.PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$softwares_id
.PluginFusioninventoryFormatconvert::FI_SOFTWARE_SEPARATOR.$a_software['operatingsystems_id']];
$changes[0] = '0';
$changes[1] = "";
$changes[2] = $a_software['name']." - ".
sprintf(__('%1$s (%2$s)'), $a_software['version'], $softwareversions_id);
$this->addPrepareLog($computers_id, 'Computer', 'SoftwareVersion', $changes,
Log::HISTORY_INSTALL_SOFTWARE);
$changes[0] = '0';
$changes[1] = "";
$changes[2] = sprintf(__('%1$s (%2$s)'), $computer->getName(), $computers_id);
$this->addPrepareLog($softwareversions_id, 'SoftwareVersion', 'Computer', $changes,
Log::HISTORY_INSTALL_SOFTWARE);
}
}
}
} else {
//It's not the first inventory, or not an OS change/upgrade
//Do software migration first if needed
$a_inventory = $this->migratePlatformForVersion($a_inventory, $db_software);
//If software exists in DB, do not process it
foreach ($a_inventory['software'] as $key => $arrayslower) {
//Software installation already exists for this computer ?
if (isset($db_software[$key])) {
//It exists: remove the software from the key
unset($a_inventory['software'][$key]);
unset($db_software[$key]);
}
}
if (count($a_inventory['software']) > 0
|| count($db_software) > 0) {
if (count($db_software) > 0) {
// Delete softwares in DB
foreach ($db_software as $idtmp) {
if (isset($this->installationWithoutLogs[$idtmp])) {
$no_history_for_this_software = true;
} else {
$no_history_for_this_software = false;
}
$this->computerSoftwareVersion->getFromDB($idtmp);
$this->softwareVersion->getFromDB($this->computerSoftwareVersion->fields['softwareversions_id']);
if (!$no_history && !$no_history_for_this_software) {
$changes[0] = '0';
$changes[1] = addslashes($this->computerSoftwareVersion->getHistoryNameForItem1($this->softwareVersion, 'delete'));
$changes[2] = "";
$this->addPrepareLog($computers_id, 'Computer', 'SoftwareVersion', $changes,
Log::HISTORY_UNINSTALL_SOFTWARE);
$changes[0] = '0';
$changes[1] = sprintf(__('%1$s (%2$s)'), $computer->getName(), $computers_id);
$changes[2] = "";
$this->addPrepareLog($idtmp, 'SoftwareVersion', 'Computer', $changes,
Log::HISTORY_UNINSTALL_SOFTWARE);
}
}
$DB->delete(
'glpi_items_softwareversions', [
'id' => $db_software
]
);
}
if (count($a_inventory['software']) > 0) {
$nb_unicity = count(FieldUnicity::getUnicityFieldsConfig("Software",
$entities_id));
$options = [];
if ($nb_unicity == 0) {
$options['disable_unicity_check'] = true;
}
$lastSoftwareid = $this->loadSoftwares($entities_id, $a_inventory['software'], $lastSoftwareid);
$dbLock->setLock('softwares');
$this->loadSoftwares($entities_id, $a_inventory['software'], $lastSoftwareid);
foreach ($a_inventory['software'] as $a_software) {
if (!isset($this->softList[$a_software['name']."$$$$".
$a_software['manufacturers_id']])) {
$this->addSoftware($a_software,
$options);
}
}
$dbLock->releaseLock('softwares');
$lastSoftwareVid = $this->loadSoftwareVersions($entities_id,
$a_inventory['software'],
$lastSoftwareVid);
$dbLock->setLock('softwareversions');
$this->loadSoftwareVersions($entities_id,
$a_inventory['software'],
$lastSoftwareVid);
foreach ($a_inventory['software'] as $a_software) {
$softwares_id = $this->softList[$a_software['name']."$$$$".$a_software['manufacturers_id']];
if (!isset($this->softVersionList[strtolower($a_software['version'])."$$$$".$softwares_id."$$$$".$a_software['operatingsystems_id']])) {
$this->addSoftwareVersion($a_software, $softwares_id, $no_history);
}
}
$dbLock->releaseLock('softwareversions');
$a_toinsert = [];
foreach ($a_inventory['software'] as $key => $a_software) {
//Check if historical has been disabled for this software only
if (isset($a_software['no_history']) && $a_software['no_history']) {
$no_history_for_this_software = true;
} else {
$no_history_for_this_software = false;
}
$softwares_id = $this->softList[$a_software['name']."$$$$".$a_software['manufacturers_id']];
$softwareversions_id = $this->softVersionList[strtolower($a_software['version'])."$$$$".$softwares_id."$$$$".$a_software['operatingsystems_id']];
$a_tmp = [
'itemtype' => 'Computer',
'items_id' => $computers_id,
'softwareversions_id' => $softwareversions_id,
'is_dynamic' => 1,
'entities_id' => $computer->fields['entities_id'],
'date_install' => null
];
if (isset($a_software['date_install'])) {
$a_tmp['date_install'] = $a_software['date_install'];
}
$a_toinsert[] = $a_tmp;
}
$this->addSoftwareVersionsComputer($a_toinsert);
if (!$no_history && !$no_history_for_this_software) {
foreach ($a_inventory['software'] as $a_software) {
$softwares_id = $this->softList[$a_software['name']."$$$$".$a_software['manufacturers_id']];
$softwareversions_id = $this->softVersionList[strtolower($a_software['version'])."$$$$".$softwares_id."$$$$".$a_software['operatingsystems_id']];
$changes[0] = '0';
$changes[1] = "";
$changes[2] = $a_software['name']." - ".
sprintf(__('%1$s (%2$s)'), $a_software['version'], $softwareversions_id);
$this->addPrepareLog($computers_id, 'Computer', 'SoftwareVersion', $changes,
Log::HISTORY_INSTALL_SOFTWARE);
$changes[0] = '0';
$changes[1] = "";
$changes[2] = sprintf(__('%1$s (%2$s)'), $computer->getName(), $computers_id);
$this->addPrepareLog($softwareversions_id, 'SoftwareVersion', 'Computer', $changes,
Log::HISTORY_INSTALL_SOFTWARE);
}
}
}
}
}
}
/**
* Migration software versions without OS
* Before 0.90, no OS was added to an installation...
*
* @since 9.2+.20
*
* @param array $a_inventory the incoming inventory as an array
* @param array $db_inventory the software inventory by reading GLPI db
* @return array the incoming inventory modified if needed
*/
function migratePlatformForVersion($a_inventory, $db_inventory) {
//Browse each software in the inventory sent by an agent
foreach ($a_inventory['software'] as $key => $software) {
//Check if the installation exists without platform (OS)
//if it is the case, then add the new and old installation
//to the list of installation/uninstallation that must not be logged
if (isset($software['comp_key_noos']) && isset($db_inventory[$software['comp_key_noos']])) {
//This array is used during version uninstallation
$this->installationWithoutLogs[] = $software['comp_key_noos'];
//This boolean is used for software version installation
$software['no_history'] = true;
//Software the modified array in the incoming inventory
$a_inventory['software'][$key] = $software;
}
}
return $a_inventory;
}
// For monitors, printers... import
function rulepassed($items_id, $itemtype, $ports_id = 0) {
return true;
}
/**
* Manage attach a device (monitor, printer....) to computer
*/
function computerItemAdd($input, $no_history) {
$computer_Item = new Computer_Item();
// Check if the device is yet connected to another computer
$computer_Item->getFromDBByCrit([
'itemtype' => $input['itemtype'],
'items_id' => $input['items_id']
]);
if (isset($computer_Item->fields['id'])) {
$computer_Item->delete(['id' => $computer_Item->fields['id']], true);
}
$computer_Item->add($input, [], !$no_history);
}
}
Zerion Mini Shell 1.0