PHP Software::putInTrash方法代码示例

 /**
  * Delete a list of softwares
  *
  * @param $soft_ids array containing replay software need to be dustbined
  **/
 function putOldSoftsInTrash(array $soft_ids)
 {
     global $DB;
     if (count($soft_ids) > 0) {
         $ids = implode("','", $soft_ids);
         //Try to delete all the software that are not used anymore
         // (which means that don't have version associated anymore)
         $res_countsoftinstall = $DB->query("SELECT `glpi_softwares`.`id`,\n                                 COUNT(`glpi_softwareversions`.`softwares_id`) AS `cpt`\n                          FROM `glpi_softwares`\n                          LEFT JOIN `glpi_softwareversions`\n                              ON `glpi_softwareversions`.`softwares_id` = `glpi_softwares`.`id`\n                          WHERE `glpi_softwares`.`id` IN ('{$ids}')\n                                AND `is_deleted` = '0'\n                          GROUP BY `glpi_softwares`.`id`\n                          HAVING `cpt` = '0'\n                          ORDER BY `cpt`");
         $software = new Software();
         while ($soft = $DB->fetch_assoc($res_countsoftinstall)) {
             $software->putInTrash($soft["id"], __('Software deleted by GLPI dictionary rules'));
         }
     }
 }

 /**
  * Test software category Rule and putInTrash / removeFromTrash
  */
 public function testSoftwareCategory()
 {
     global $CFG_GLPI;
     $ent0 = $this->sharedFixture['entity'][0];
     // Clean preload rules
     $tmp = SingletonRuleList::getInstance('RuleSoftwareCategory');
     $tmp->load = 0;
     $this->assertArrayHasKey('softwarecategories_id_ondelete', $CFG_GLPI, "Fail: no softwarecategories_id_ondelete");
     $idcat[0] = Dropdown::import('SoftwareCategory', array('name' => 'Trashed'));
     $this->assertGreaterThan(0, $idcat[0], "Fail: can't create SoftwareCategory");
     $idcat[1] = Dropdown::import('SoftwareCategory', array('name' => 'OpenSource'));
     $this->assertGreaterThan(0, $idcat[1], "Fail: can't create SoftwareCategory");
     $rule = new RuleSoftwareCategory();
     $crit = new RuleCriteria();
     $acte = new RuleAction();
     $idr[0] = $rule->add(array('name' => 'OSS', 'sub_type' => 'RuleSoftwareCategory', 'match' => 'AND', 'is_active' => 1));
     $this->assertGreaterThan(0, $idr[0], "Fail: can't create rule 1");
     $this->assertTrue($rule->getFromDB($idr[0]));
     $this->assertEquals(1, $rule->fields['ranking'], "Fail: ranking not set");
     $idc[0] = $crit->add(array('rules_id' => $idr[0], 'criteria' => 'manufacturer', 'condition' => Rule::PATTERN_IS, 'pattern' => 'Indepnet'));
     $this->assertGreaterThan(0, $idc[0], "Fail: can't create rule 1 criteria");
     $ida[0] = $acte->add(array('rules_id' => $idr[0], 'action_type' => 'assign', 'field' => 'softwarecategories_id', 'value' => $idcat[1]));
     $this->assertGreaterThan(0, $ida[0], "Fail: can't create rule 1 action");
     // Createthe software
     $soft = new Software();
     $id[0] = $soft->addOrRestoreFromTrash('GLPI', 'Indepnet', $ent0);
     $this->assertGreaterThan(0, $id[0], "Fail: can't create software 1");
     // Check name
     $this->assertTrue($soft->getFromDB($id[0]), "Fail: can't read new soft");
     $this->assertEquals('GLPI', $soft->getField('name'), "Fail: name not set");
     // Check category
     $catid = $soft->getField('softwarecategories_id');
     $this->assertEquals($idcat[1], $catid, "Fail: category not set");
     // Change configuration
     $CFG_GLPI["softwarecategories_id_ondelete"] = $idcat[0];
     // Delete
     $this->assertTrue($soft->putInTrash($id[0]), "Fail: can't put soft in trash");
     $this->assertTrue($soft->getFromDB($id[0]), "Fail: can't read new soft");
     $catid = $soft->getField('softwarecategories_id');
     $this->assertEquals($idcat[0], $catid, "Fail: category not set");
     $this->assertEquals(1, $soft->getField('is_deleted'), "Fail: soft not deleted");
     // Restore
     $this->assertTrue($soft->removeFromTrash($id[0]), "Fail: can't put soft in trash");
     $this->assertTrue($soft->getFromDB($id[0]), "Fail: can't read new soft");
     $catid = $soft->getField('softwarecategories_id');
     $this->assertEquals($idcat[1], $catid, "Fail: category not set");
     $this->assertEquals(0, $soft->getField('is_deleted'), "Fail: soft not restored");
     // Clean
     $this->assertTrue($soft->delete(array('id' => $id[0]), true), "Fail: can't delete software 1)");
 }

//.........这里部分代码省略.........
         } else {
             $query2 = "SELECT `softwares`.`NAME` AS NAME,\n                              `softwares`.`VERSION` AS VERSION,\n                              `softwares`.`PUBLISHER` AS PUBLISHER,\n                              `softwares`.`COMMENTS` AS COMMENTS\n                       FROM `softwares`\n                       WHERE `softwares`.`HARDWARE_ID` = '{$ocsid}'";
         }
         $result2 = $PluginOcsinventoryngDBocs->query($query2);
         $soft = new Software();
         // Read imported software in last sync
         $query = "SELECT `glpi_computers_softwareversions`.`id` as id,\n                          `glpi_softwares`.`name` as sname,\n                          `glpi_softwareversions`.`name` as vname\n                   FROM `glpi_computers_softwareversions`\n                   INNER JOIN `glpi_softwareversions`\n                           ON `glpi_softwareversions`.`id`= `glpi_computers_softwareversions`.`softwareversions_id`\n                   INNER JOIN `glpi_softwares`\n                           ON `glpi_softwares`.`id`= `glpi_softwareversions`.`softwares_id`\n                   WHERE `glpi_computers_softwareversions`.`computers_id`='{$computers_id}'\n                         AND `is_dynamic`";
         $imported = array();
         foreach ($DB->request($query) as $data) {
             $imported[$data['id']] = strtolower($data['sname'] . self::FIELD_SEPARATOR . $data['vname']);
         }
         if ($PluginOcsinventoryngDBocs->numrows($result2) > 0) {
             while ($data2 = $PluginOcsinventoryngDBocs->fetch_array($result2)) {
                 $data2 = Toolbox::clean_cross_side_scripting_deep(Toolbox::addslashes_deep($data2));
                 //As we cannot be sure that data coming from OCS are in utf8, let's try to encode them
                 //if possible
                 foreach (array('NAME', 'PUBLISHER', 'VERSION') as $field) {
                     $data2[$field] = self::encodeOcsDataInUtf8($is_utf8, $data2[$field]);
                 }
                 //Replay dictionnary on manufacturer
                 $manufacturer = Manufacturer::processName($data2["PUBLISHER"]);
                 $version = $data2['VERSION'];
                 $name = $data2['NAME'];
                 //Software might be created in another entity, depending on the entity's configuration
                 $target_entity = Entity::getUsedConfig('entities_id_software', $entity, '', true);
                 //Do not change software's entity except if the dictionnary explicity changes it
                 if ($target_entity < 0) {
                     $target_entity = $entity;
                 }
                 $modified_name = $name;
                 $modified_version = $version;
                 $is_helpdesk_visible = NULL;
                 if (!$cfg_ocs["use_soft_dict"]) {
                     //Software dictionnary
                     $params = array("name" => $name, "manufacturer" => $manufacturer, "old_version" => $version, "entities_id" => $entity);
                     $rulecollection = new RuleDictionnarySoftwareCollection();
                     $res_rule = $rulecollection->processAllRules(Toolbox::stripslashes_deep($params), array(), Toolbox::stripslashes_deep(array('version' => $version)));
                     if (isset($res_rule["name"]) && $res_rule["name"]) {
                         $modified_name = $res_rule["name"];
                     }
                     if (isset($res_rule["version"]) && $res_rule["version"]) {
                         $modified_version = $res_rule["version"];
                     }
                     if (isset($res_rule["is_helpdesk_visible"]) && strlen($res_rule["is_helpdesk_visible"])) {
                         $is_helpdesk_visible = $res_rule["is_helpdesk_visible"];
                     }
                     if (isset($res_rule['manufacturer']) && $res_rule['manufacturer']) {
                         $manufacturer = Dropdown::getDropdownName('glpi_manufacturers', $res_rule['manufacturer']);
                         $manufacturer = Toolbox::addslashes_deep($manufacturer);
                     }
                     //If software dictionnary returns an entity, it overrides the one that may have
                     //been defined in the entity's configuration
                     if (isset($res_rule["new_entities_id"]) && strlen($res_rule["new_entities_id"])) {
                         $target_entity = $res_rule["new_entities_id"];
                     }
                 }
                 //If software must be imported
                 if (!isset($res_rule["_ignore_import"]) || !$res_rule["_ignore_import"]) {
                     // Clean software object
                     $soft->reset();
                     // EXPLANATION About dictionnaries
                     // OCS dictionnary : if software name change, as we don't store INITNAME
                     //     GLPI will detect an uninstall (oldname) + install (newname)
                     // GLPI dictionnary : is rule have change
                     //     if rule have been replayed, modifiedname will be found => ok
                     //     if not, GLPI will detect an uninstall (oldname) + install (newname)
                     $id = array_search(strtolower(stripslashes($modified_name . self::FIELD_SEPARATOR . $version)), $imported);
                     if ($id) {
                         //-------------------------------------------------------------------------//
                         //---- The software exists in this version for this computer --------------//
                         //---------------------------------------------------- --------------------//
                         unset($imported[$id]);
                     } else {
                         //------------------------------------------------------------------------//
                         //---- The software doesn't exists in this version for this computer -----//
                         //------------------------------------------------------------------------//
                         $isNewSoft = $soft->addOrRestoreFromTrash($modified_name, $manufacturer, $target_entity, '', $entity != $target_entity, $is_helpdesk_visible);
                         //Import version for this software
                         $versionID = self::importVersion($isNewSoft, $modified_version);
                         //Install license for this machine
                         $instID = self::installSoftwareVersion($computers_id, $versionID, $dohistory);
                     }
                 }
             }
         }
         foreach ($imported as $id => $unused) {
             $computer_softwareversion->delete(array('id' => $id, '_no_history' => !$dohistory), true);
             // delete cause a getFromDB, so fields contains values
             $verid = $computer_softwareversion->getField('softwareversions_id');
             if (countElementsInTable('glpi_computers_softwareversions', "softwareversions_id = '{$verid}'") == 0 && countElementsInTable('glpi_softwarelicenses', "softwareversions_id_buy = '{$verid}'") == 0) {
                 $vers = new SoftwareVersion();
                 if ($vers->getFromDB($verid) && countElementsInTable('glpi_softwarelicenses', "softwares_id = '" . $vers->fields['softwares_id'] . "'") == 0 && countElementsInTable('glpi_softwareversions', "softwares_id = '" . $vers->fields['softwares_id'] . "'") == 1) {
                     // 1 is the current to be removed
                     $soft->putInTrash($vers->fields['softwares_id'], __('Software deleted by OCSNG synchronization'));
                 }
                 $vers->delete(array("id" => $verid));
             }
         }
     }
 }

//.........这里部分代码省略.........
                 if (!$cfg_ocs["use_soft_dict"]) {
                     //Software dictionnary
                     $rulecollection = new RuleDictionnarySoftwareCollection();
                     $res_rule = $rulecollection->processAllRules(array("name" => $name, "manufacturer" => $manufacturer, "old_version" => $version), array(), array('version' => $version));
                     $res_rule = addslashes_deep($res_rule);
                     if (isset($res_rule["name"])) {
                         $modified_name = $res_rule["name"];
                     } else {
                         $modified_name = $name;
                     }
                     if (isset($res_rule["version"]) && $res_rule["version"] != '') {
                         $modified_version = $res_rule["version"];
                     } else {
                         $modified_version = $version;
                     }
                 } else {
                     $modified_name = $name;
                     $modified_version = $version;
                 }
                 //Ignore this software
                 if (!isset($res_rule["_ignore_ocs_import"]) || !$res_rule["_ignore_ocs_import"]) {
                     // Clean software object
                     $soft->reset();
                     //If name+version not in present for this computer in glpi, add it
                     if (!in_array(stripslashes($initname . self::FIELD_SEPARATOR . $version), $import_software)) {
                         //------------------------------------------------------------------------//
                         //---- The software doesn't exists in this version for this computer -----//
                         //------------------------------------------------------------------------//
                         $isNewSoft = $soft->addOrRestoreFromTrash($modified_name, $manufacturer, $entity);
                         //Import version for this software
                         $versionID = self::importVersion($isNewSoft, $modified_version);
                         //Install license for this machine
                         $instID = self::installSoftwareVersion($computers_id, $versionID, $dohistory);
                         //Add the software to the table of softwares for this computer to add in database
                         $to_add_to_ocs_array[$instID] = $initname . self::FIELD_SEPARATOR . $version;
                     } else {
                         $instID = -1;
                         //-------------------------------------------------------------------------//
                         //---- The software exists in this version for this computer --------------//
                         //---------------------------------------------------- --------------------//
                         //Get the name of the software in GLPI to know if the software's name
                         //have already been changed by the OCS dictionnary
                         $instID = array_search(stripslashes($initname . self::FIELD_SEPARATOR . $version), $import_software);
                         $query_soft = "SELECT `glpi_softwares`.`id`,\n                                           `glpi_softwares`.`name`,\n                                           `glpi_softwares`.`entities_id`\n                                    FROM `glpi_softwares`,\n                                         `glpi_computers_softwareversions`,\n                                         `glpi_softwareversions`\n                                    WHERE `glpi_computers_softwareversions`.`id` = '{$instID}'\n                                          AND `glpi_computers_softwareversions`.`softwareversions_id`\n                                                = `glpi_softwareversions`.`id`\n                                          AND `glpi_softwareversions`.`softwares_id`\n                                                = `glpi_softwares`.`id`";
                         $result_soft = $DB->query($query_soft);
                         $tmpsoft = $DB->fetch_array($result_soft);
                         $softName = $tmpsoft["name"];
                         $softID = $tmpsoft["id"];
                         $s = new Software();
                         $input["id"] = $softID;
                         $input["entities_id"] = $tmpsoft['entities_id'];
                         //First, get the name of the software into GLPI db IF dictionnary is used
                         if ($cfg_ocs["use_soft_dict"]) {
                             //First use of the OCS dictionnary OR name changed in the dictionnary
                             if ($softName != $name) {
                                 $input["name"] = $name;
                                 $s->update($input);
                             }
                         } else {
                             if ($softName != $modified_name) {
                                 // OCS Dictionnary not use anymore : revert to original name
                                 $input["name"] = $modified_name;
                                 $s->update($input);
                             }
                         }
                         unset($import_software[$instID]);
                     }
                 }
             }
         }
         //Remove the tag from the import_software array
         unset($import_software[0]);
         //Add all the new softwares
         if (count($to_add_to_ocs_array)) {
             self::addToOcsArray($computers_id, $to_add_to_ocs_array, "import_software");
         }
         // Remove softwares not present in OCS
         if (count($import_software)) {
             $inst = new Computer_SoftwareVersion();
             foreach ($import_software as $key => $val) {
                 $query = "SELECT *\n                         FROM `glpi_computers_softwareversions`\n                         WHERE `id` = '{$key}'";
                 $result = $DB->query($query);
                 if ($DB->numrows($result) > 0) {
                     if ($data = $DB->fetch_assoc($result)) {
                         $inst->delete(array('id' => $key, '_no_history' => !$dohistory));
                         if (countElementsInTable('glpi_computers_softwareversions', "softwareversions_id = '" . $data['softwareversions_id'] . "'") == 0 && countElementsInTable('glpi_softwarelicenses', "softwareversions_id_buy = '" . $data['softwareversions_id'] . "'") == 0) {
                             $vers = new SoftwareVersion();
                             if ($vers->getFromDB($data['softwareversions_id']) && countElementsInTable('glpi_softwarelicenses', "softwares_id = '" . $vers->fields['softwares_id'] . "'") == 0 && countElementsInTable('glpi_softwareversions', "softwares_id = '" . $vers->fields['softwares_id'] . "'") == 1) {
                                 // 1 is the current to be removed
                                 $soft->putInTrash($vers->fields['softwares_id'], $LANG['ocsng'][54]);
                             }
                             $vers->delete(array("id" => $data['softwareversions_id']));
                         }
                     }
                 }
                 self::deleteInOcsArray($computers_id, $key, "import_software");
             }
         }
     }
 }