<?php

/**
 * FusionInventory
 *
 * Copyright (C) 2010-2016 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 collect (registry, file, wmi) module of
 * the agents
 *
 * ------------------------------------------------------------------------
 *
 * @package   FusionInventory
 * @author    David Durieux
 * @copyright Copyright (c) 2010-2016 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 collect information by the agent.
 */
class PluginFusioninventoryCollect extends CommonDBTM {

   /**
    * The right name for this class
    *
    * @var string
    */
   static $rightname = 'plugin_fusioninventory_collect';


   /**
    * Get name of this type by language of the user connected
    *
    * @param integer $nb number of elements
    * @return string name of this type
    */
   static function getTypeName($nb = 0) {
      return __('Collect information', 'fusioninventory');
   }


   /**
    * Get the tab name used for item
    *
    * @param object $item the item object
    * @param integer $withtemplate 1 if is a template form
    * @return string name of the tab
    */
   function getTabNameForItem(CommonGLPI $item, $withtemplate = 0) {
      if ($item->fields['id'] > 0) {
         $index = self::getNumberOfCollectsForAComputer($item->fields['id']);
         $nb    = 0;
         if ($index > 0) {
            if ($_SESSION['glpishow_count_on_tabs']) {
               $nb = $index;
            }
            return self::createTabEntry(self::getTypeName(Session::getPluralNumber()), $nb);
         }
      }
      return '';
   }


   /**
    * Display the content of the tab
    *
    * @param object $item
    * @param integer $tabnum number of the tab to display
    * @param integer $withtemplate 1 if is a template form
    * @return boolean
    */
   static function displayTabContentForItem(CommonGLPI $item, $tabnum = 1, $withtemplate = 0) {
      $pfComputer = new PluginFusioninventoryInventoryComputerComputer();
      $id = $item->fields['id'];
      if ($item->getType() == 'Computer'
         && $pfComputer->hasAutomaticInventory($id)) {
         foreach (['PluginFusioninventoryCollect_File_Content',
                   'PluginFusioninventoryCollect_Wmi_Content',
                   'PluginFusioninventoryCollect_Registry_Content'] as $itemtype) {
            $collect_item = new $itemtype();
            $collect_item->showForComputer($id);
         }
      }
      return false;
   }


   /**
   * Get the number of collects for a computer
   * @since 9.2
   *
   * @param integer $computers_id the computer ID
   * @return the number of collects for this computer
   */
   static function getNumberOfCollectsForAComputer($computers_id) {
      $tables = ['glpi_plugin_fusioninventory_collects_registries_contents',
                 'glpi_plugin_fusioninventory_collects_wmis_contents',
                 'glpi_plugin_fusioninventory_collects_files_contents',
                ];
      $total = 0;
      foreach ($tables as $table) {
         $total+= countElementsInTable($table, ['computers_id' => $computers_id]);
      }
      return $total;
   }


   /**
    * Get all collect types
    *
    * @return array [name] => description
    */
   static function getTypes() {
      return [
         'registry' => __('Registry', 'fusioninventory'),
         'wmi'      => __('WMI', 'fusioninventory'),
         'file'     => __('Find file', 'fusioninventory')
      ];
   }

   function rawSearchOptions() {

      $tab = [];

      $tab[] = [
         'id'           => 'common',
         'name'         => __('Characteristics')
      ];

      $tab[] = [
         'id'           => '1',
         'table'        => $this->getTable(),
         'field'        => 'name',
         'name'         => __('Name'),
         'datatype'     => 'itemlink',
         'autocomplete' => true,
      ];

      return $tab;
   }


   /**
    * Add search options
    *
    * @return array
    */
   static function getSearchOptionsToAdd($itemtype = null) {
      $tab = [];

      $i = 5200;

      $pfCollect = new PluginFusioninventoryCollect();
      foreach ($pfCollect->find(getEntitiesRestrictCriteria($pfCollect->getTable(), '', '', true), ['id ASC']) as $collect) {

         //registries
         $pfCollect_Registry = new PluginFusioninventoryCollect_Registry();
         $registries = $pfCollect_Registry->find(['plugin_fusioninventory_collects_id' => $collect['id']], ['id ASC']);
         foreach ($registries as $registry) {
            $tab[$i]['table']         = 'glpi_plugin_fusioninventory_collects_registries_contents';
            $tab[$i]['field']         = 'value';
            $tab[$i]['linkfield']     = '';
            $tab[$i]['name']          = __('Registry', 'fusioninventory')." - ".$registry['name'];
            $tab[$i]['joinparams']    = ['jointype' => 'child'];
            $tab[$i]['datatype']      = 'text';
            $tab[$i]['forcegroupby']  = true;
            $tab[$i]['massiveaction'] = false;
            $tab[$i]['nodisplay']     = true;
            $tab[$i]['joinparams']    = ['condition' => "AND NEWTABLE.`plugin_fusioninventory_collects_registries_id` = ".$registry['id'],
                                          'jointype' => 'child'];
            $i++;
         }

         //WMIs
         $pfCollect_Wmi = new PluginFusioninventoryCollect_Wmi();
         $wmis = $pfCollect_Wmi->find(['plugin_fusioninventory_collects_id'  => $collect['id']], ['id ASC']);
         foreach ($wmis as $wmi) {
            $tab[$i]['table']         = 'glpi_plugin_fusioninventory_collects_wmis_contents';
            $tab[$i]['field']         = 'value';
            $tab[$i]['linkfield']     = '';
            $tab[$i]['name']          = __('WMI', 'fusioninventory')." - ".$wmi['name'];
            $tab[$i]['joinparams']    = ['jointype' => 'child'];
            $tab[$i]['datatype']      = 'text';
            $tab[$i]['forcegroupby']  = true;
            $tab[$i]['massiveaction'] = false;
            $tab[$i]['nodisplay']     = true;
            $tab[$i]['joinparams']    = ['condition' => "AND NEWTABLE.`plugin_fusioninventory_collects_wmis_id` = ".$wmi['id'],
                                          'jointype' => 'child'];
            $i++;
         }

         //Files
         $pfCollect_File = new PluginFusioninventoryCollect_File();
         $files = $pfCollect_File->find(['plugin_fusioninventory_collects_id' => $collect['id']], ['id ASC']);
         foreach ($files as $file) {

            $tab[$i]['table']         = 'glpi_plugin_fusioninventory_collects_files_contents';
            $tab[$i]['field']         = 'pathfile';
            $tab[$i]['linkfield']     = '';
            $tab[$i]['name']          = __('Find file', 'fusioninventory').
                                    " - ".$file['name'].
                                    " - ".__('pathfile', 'fusioninventory');
            $tab[$i]['joinparams']    = ['jointype' => 'child'];
            $tab[$i]['datatype']      = 'text';
            $tab[$i]['forcegroupby']  = true;
            $tab[$i]['massiveaction'] = false;
            $tab[$i]['nodisplay']     = true;
            $tab[$i]['joinparams']    = ['condition' => "AND NEWTABLE.`plugin_fusioninventory_collects_files_id` = ".$file['id'],
                                          'jointype' => 'child'];
            $i++;

            $tab[$i]['table']         = 'glpi_plugin_fusioninventory_collects_files_contents';
            $tab[$i]['field']         = 'size';
            $tab[$i]['linkfield']     = '';
            $tab[$i]['name']          = __('Find file', 'fusioninventory').
                                    " - ".$file['name'].
                                    " - ".__('Size', 'fusioninventory');
            $tab[$i]['joinparams']    = ['jointype' => 'child'];
            $tab[$i]['datatype']      = 'text';
            $tab[$i]['forcegroupby']  = true;
            $tab[$i]['massiveaction'] = false;
            $tab[$i]['nodisplay']     = true;
            $tab[$i]['joinparams']    = ['condition' => "AND NEWTABLE.`plugin_fusioninventory_collects_files_id` = ".$file['id'],
                                          'jointype' => 'child'];
            $i++;
         }
      }
      return $tab;
   }


   /**
    * Display form
    *
    * @param integer $ID
    * @param array $options
    * @return true
    */
   function showForm($ID, $options = []) {

      $this->initForm($ID, $options);
      $this->showFormHeader($options);

      echo "<tr class='tab_bg_1'>";
      echo "<td>";
      echo __('Name');
      echo "</td>";
      echo "<td>";
      Html::autocompletionTextField($this, 'name');
      echo "</td>";
      echo "<td>".__('Type')."</td>";
      echo "<td>";
      Dropdown::showFromArray('type',
                              PluginFusioninventoryCollect::getTypes(),
                              ['value' => $this->fields['type']]);
      echo "</td>";
      echo "</tr>\n";

      echo "<tr class='tab_bg_1'>";
      echo "<td>";
      echo __('Comments');
      echo "</td>";
      echo "<td class='middle'>";
      echo "<textarea cols='45' rows='3' name='comment' >".
              $this->fields["comment"]."</textarea>";
      echo "</td>";
      echo "<td>".__('Active')."</td>";
      echo "<td>";
      Dropdown::showYesNo('is_active', $this->fields['is_active']);
      echo "</td>";
      echo "</tr>\n";

      $this->showFormButtons($options);

      return true;
   }


   /**
    * Prepare run, so it prepare the taskjob with module 'collect'.
    * It prepare collect information and computer list for task run
    *
    * @global object $DB
    * @param integer $taskjobs_id id of taskjob
    */
   function prepareRun($taskjobs_id) {
      global $DB;

      $task       = new PluginFusioninventoryTask();
      $job        = new PluginFusioninventoryTaskjob();
      $joblog     = new PluginFusioninventoryTaskjoblog();
      $jobstate   = new PluginFusioninventoryTaskjobstate();
      $agent      = new PluginFusioninventoryAgent();

      $job->getFromDB($taskjobs_id);
      $task->getFromDB($job->fields['plugin_fusioninventory_tasks_id']);

      $communication = $task->fields['communication'];
      $actions       = importArrayFromDB($job->fields['action']);
      $definitions   = importArrayFromDB($job->fields['definition']);
      $taskvalid     = 0;

      $computers = [];
      foreach ($actions as $action) {
         $itemtype = key($action);
         $items_id = current($action);

         switch ($itemtype) {

            case 'Computer':
               $computers[] = $items_id;
               break;

            case 'Group':
               $computer_object = new Computer();

               //find computers by user associated with this group
               $group_users   = new Group_User();
               $group         = new Group();
               $group->getFromDB($items_id);

               $computers_a_1 = [];
               $computers_a_2 = [];

               $members = $group_users->getGroupUsers($items_id);

               foreach ($members as $member) {
                  $computers = $computer_object->find(['users_id' => $member['id']]);
                  foreach ($computers as $computer) {
                     $computers_a_1[] = $computer['id'];
                  }
               }

               //find computers directly associated with this group
               $computers = $computer_object->find(['groups_id' => $items_id]);
               foreach ($computers as $computer) {
                  $computers_a_2[] = $computer['id'];
               }

               //merge two previous array and deduplicate entries
               $computers = array_unique(array_merge($computers_a_1, $computers_a_2));
               break;

            case 'PluginFusioninventoryDeployGroup':
               $group = new PluginFusioninventoryDeployGroup;
               $group->getFromDB($items_id);

               switch ($group->getField('type')) {

                  case 'STATIC':
                     $query = "SELECT items_id
                     FROM glpi_plugin_fusioninventory_deploygroups_staticdatas
                     WHERE groups_id = '$items_id'
                     AND itemtype = 'Computer'";
                     $res = $DB->query($query);
                     while ($row = $DB->fetchAssoc($res)) {
                        $computers[] = $row['items_id'];
                     }
                     break;

                  case 'DYNAMIC':
                     $query = "SELECT fields_array
                     FROM glpi_plugin_fusioninventory_deploygroups_dynamicdatas
                     WHERE groups_id = '$items_id'
                     LIMIT 1";
                     $res = $DB->query($query);
                     $row = $DB->fetchAssoc($res);

                     if (isset($_GET)) {
                        $get_tmp = $_GET;
                     }
                     if (isset($_SESSION["glpisearchcount"]['Computer'])) {
                        unset($_SESSION["glpisearchcount"]['Computer']);
                     }
                     if (isset($_SESSION["glpisearchcount2"]['Computer'])) {
                        unset($_SESSION["glpisearchcount2"]['Computer']);
                     }

                     $_GET = importArrayFromDB($row['fields_array']);

                     $_GET["glpisearchcount"] = count($_GET['field']);
                     if (isset($_GET['field2'])) {
                        $_GET["glpisearchcount2"] = count($_GET['field2']);
                     }

                     $pfSearch = new PluginFusioninventorySearch();
                     $glpilist_limit = $_SESSION['glpilist_limit'];
                     $_SESSION['glpilist_limit'] = 999999999;
                     $result = $pfSearch->constructSQL('Computer',
                                                       $_GET);
                     $_SESSION['glpilist_limit'] = $glpilist_limit;
                     while ($data=$DB->fetchArray($result)) {
                        $computers[] = $data['id'];
                     }
                     if (count($get_tmp) > 0) {
                        $_GET = $get_tmp;
                     }
                     break;

               }
               break;

         }
      }

      $c_input= [];
      $c_input['plugin_fusioninventory_taskjobs_id'] = $taskjobs_id;
      $c_input['state']                              = 0;
      $c_input['plugin_fusioninventory_agents_id']   = 0;
      $c_input['execution_id']                       = $task->fields['execution_id'];

      $pfCollect = new PluginFusioninventoryCollect();

      foreach ($computers as $computer_id) {
         //get agent if for this computer
         $agents_id = $agent->getAgentWithComputerid($computer_id);
         if ($agents_id === false) {
            $jobstates_id = $jobstate->add($c_input);
            $jobstate->changeStatusFinish($jobstates_id,
                                          0,
                                          '',
                                          1,
                                          "No agent found for [[Computer::".$computer_id."]]");
         } else {
            foreach ($definitions as $definition) {
               $pfCollect->getFromDB($definition['PluginFusioninventoryCollect']);

               switch ($pfCollect->fields['type']) {

                  case 'registry':
                     // get all registry
                     $pfCollect_Registry = new PluginFusioninventoryCollect_Registry();
                     $a_registries = $pfCollect_Registry->find(
                             ['plugin_fusioninventory_collects_id' => $pfCollect->fields['id']]);
                     foreach ($a_registries as $data_r) {
                        $uniqid= uniqid();
                        $c_input['state'] = 0;
                        $c_input['itemtype'] = 'PluginFusioninventoryCollect_Registry';
                        $c_input['items_id'] = $data_r['id'];
                        $c_input['date'] = date("Y-m-d H:i:s");
                        $c_input['uniqid'] = $uniqid;

                        $c_input['plugin_fusioninventory_agents_id'] = $agents_id;

                        // Push the agent, in the stack of agent to awake
                        if ($communication == "push") {
                           $_SESSION['glpi_plugin_fusioninventory']['agents'][$agents_id] = 1;
                        }

                        $jobstates_id= $jobstate->add($c_input);

                        //Add log of taskjob
                        $c_input['plugin_fusioninventory_taskjobstates_id'] = $jobstates_id;
                        $c_input['state']= PluginFusioninventoryTaskjoblog::TASK_PREPARED;
                        $taskvalid++;
                        $joblog->add($c_input);
                     }
                     break;

                  case 'wmi':
                     // get all wmi
                     $pfCollect_Wmi = new PluginFusioninventoryCollect_Wmi();
                     $a_wmies = $pfCollect_Wmi->find(
                             ['plugin_fusioninventory_collects_id' => $pfCollect->fields['id']]);
                     foreach ($a_wmies as $data_r) {
                        $uniqid= uniqid();
                        $c_input['state'] = 0;
                        $c_input['itemtype'] = 'PluginFusioninventoryCollect_Wmi';
                        $c_input['items_id'] = $data_r['id'];
                        $c_input['date'] = date("Y-m-d H:i:s");
                        $c_input['uniqid'] = $uniqid;

                        $c_input['plugin_fusioninventory_agents_id'] = $agents_id;

                        // Push the agent, in the stack of agent to awake
                        if ($communication == "push") {
                           $_SESSION['glpi_plugin_fusioninventory']['agents'][$agents_id] = 1;
                        }

                        $jobstates_id= $jobstate->add($c_input);

                        //Add log of taskjob
                        $c_input['plugin_fusioninventory_taskjobstates_id'] = $jobstates_id;
                        $c_input['state']= PluginFusioninventoryTaskjoblog::TASK_PREPARED;
                        $taskvalid++;
                        $joblog->add($c_input);
                     }
                     break;

                  case 'file':
                     // find files
                     $pfCollect_File = new PluginFusioninventoryCollect_File();
                     $a_files = $pfCollect_File->find(
                             ['plugin_fusioninventory_collects_id' => $pfCollect->fields['id']]);
                     foreach ($a_files as $data_r) {
                        $uniqid= uniqid();
                        $c_input['state'] = 0;
                        $c_input['itemtype'] = 'PluginFusioninventoryCollect_File';
                        $c_input['items_id'] = $data_r['id'];
                        $c_input['date'] = date("Y-m-d H:i:s");
                        $c_input['uniqid'] = $uniqid;

                        $c_input['plugin_fusioninventory_agents_id'] = $agents_id;

                        // Push the agent, in the stack of agent to awake
                        if ($communication == "push") {
                           $_SESSION['glpi_plugin_fusioninventory']['agents'][$agents_id] = 1;
                        }

                        $jobstates_id= $jobstate->add($c_input);

                        //Add log of taskjob
                        $c_input['plugin_fusioninventory_taskjobstates_id'] = $jobstates_id;
                        $c_input['state']= PluginFusioninventoryTaskjoblog::TASK_PREPARED;
                        $taskvalid++;
                        $joblog->add($c_input);
                     }
                     break;

               }
            }
         }
      }

      if ($taskvalid > 0) {
         $job->fields['status']= 1;
         $job->update($job->fields);
      } else {
         $job->reinitializeTaskjobs($job->fields['plugin_fusioninventory_tasks_id']);
      }
   }


   /**
    * run function, so return data to send to the agent for collect information
    *
    * @param object $taskjobstate PluginFusioninventoryTaskjobstate instance
    * @param array $agent agent information from agent table in database
    * @return array
    */
   function run($taskjobstate, $agent) {
      global $DB;

      $output = [];

      $this->getFromDB($taskjobstate->fields['items_id']);
      $sql_where = ['plugin_fusioninventory_collects_id' => $this->fields['id']];

      switch ($this->fields['type']) {

         case 'registry':
            $pfCollect_Registry = new PluginFusioninventoryCollect_Registry();
            $reg_db = $pfCollect_Registry->find($sql_where);
            foreach ($reg_db as $reg) {
               $output[] = [
                   'function' => 'getFromRegistry',
                   'path'     => $reg['hive'].$reg['path'].$reg['key'],
                   'uuid'     => $taskjobstate->fields['uniqid'],
                   '_sid'     => $reg['id']
               ];
            }
            break;

         case 'wmi':
            $pfCollect_Wmi = new PluginFusioninventoryCollect_Wmi();
            $wmi_db = $pfCollect_Wmi->find($sql_where);
            foreach ($wmi_db as $wmi) {
               $datawmi = [
                   'function'   => 'getFromWMI',
                   'class'      => $wmi['class'],
                   'properties' => [$wmi['properties']],
                   'uuid'       => $taskjobstate->fields['uniqid'],
                   '_sid'       => $wmi['id']];
               if ($wmi['moniker'] != '') {
                  $datawmi['moniker'] = $wmi['moniker'];
               }
               $output[] = $datawmi;
            }

            break;

         case 'file':
            $pfCollect_File = new PluginFusioninventoryCollect_File();
            $files_db = $pfCollect_File->find($sql_where);
            foreach ($files_db as $files) {
               $datafile = [
                  'function'  => 'findFile',
                  'dir'       => $files['dir'],
                  'limit'     => $files['limit'],
                  'recursive' => $files['is_recursive'],
                  'filter'    => [
                     'is_file' => $files['filter_is_file'],
                     'is_dir'  => $files['filter_is_dir']
                  ],
                  'uuid'      => $taskjobstate->fields['uniqid'],
                  '_sid'       => $files['id']
               ];
               if ($files['filter_regex'] != '') {
                  $datafile['filter']['regex'] = $files['filter_regex'];
               }
               if ($files['filter_sizeequals'] > 0) {
                  $datafile['filter']['sizeEquals'] = $files['filter_sizeequals'];
               } else if ($files['filter_sizegreater'] > 0) {
                  $datafile['filter']['sizeGreater'] = $files['filter_sizegreater'];
               } else if ($files['filter_sizelower'] > 0) {
                  $datafile['filter']['sizeLower'] = $files['filter_sizelower'];
               }
               if ($files['filter_checksumsha512'] != '') {
                  $datafile['filter']['checkSumSHA512'] = $files['filter_checksumsha512'];
               }
               if ($files['filter_checksumsha2'] != '') {
                  $datafile['filter']['checkSumSHA2'] = $files['filter_checksumsha2'];
               }
               if ($files['filter_name'] != '') {
                  $datafile['filter']['name'] = $files['filter_name'];
               }
               if ($files['filter_iname'] != '') {
                  $datafile['filter']['iname'] = $files['filter_iname'];
               }
               $output[] = $datafile;

               //clean old files
               $DB->delete(
                  'glpi_plugin_fusioninventory_collects_files_contents', [
                     'plugin_fusioninventory_collects_files_id'   => $files['id'],
                     'computers_id'                               => $agent['computers_id']
                  ]
               );
            }
            break;

      }
      return $output;
   }


   function communication($action, $machineId, $uuid) {
      $response = new \stdClass();

      if (empty($action)) {
         return $response;
      }

      $pfAgent        = new PluginFusioninventoryAgent();
      $pfTaskjobstate = new PluginFusioninventoryTaskjobstate();
      $pfTaskjoblog   = new PluginFusioninventoryTaskjoblog();

      switch ($action) {

         case 'getJobs':
            if (empty($machineId)) {
               return $response;
            }
            $pfAgentModule  = new PluginFusioninventoryAgentmodule();
            $pfTask         = new PluginFusioninventoryTask();

            $agent = $pfAgent->infoByKey(Toolbox::addslashes_deep($machineId));
            if (isset($agent['id'])) {
               $taskjobstates = $pfTask->getTaskjobstatesForAgent(
                  $agent['id'],
                  ['collect']
               );
               $order = new \stdClass();
               $order->jobs = [];

               foreach ($taskjobstates as $taskjobstate) {
                  if (!$pfAgentModule->isAgentCanDo("Collect", $agent['id'])) {
                     $taskjobstate->cancel(
                        __("Collect module has been disabled for this agent", 'fusioninventory')
                     );
                  } else {
                     $out = $this->run($taskjobstate, $agent);
                     if (count($out) > 0) {
                        $order->jobs = array_merge($order->jobs, $out);
                     }

                     // change status of state table row
                     $pfTaskjobstate->changeStatus(
                           $taskjobstate->fields['id'],
                           PluginFusioninventoryTaskjobstate::SERVER_HAS_SENT_DATA
                     );

                     $a_input = [
                           'plugin_fusioninventory_taskjobstates_id'    => $taskjobstate->fields['id'],
                           'items_id'                                   => $agent['id'],
                           'itemtype'                                   => 'PluginFusioninventoryAgent',
                           'date'                                       => date("Y-m-d H:i:s"),
                           'comment'                                    => '',
                           'state'                                      => PluginFusioninventoryTaskjoblog::TASK_STARTED
                     ];
                     $pfTaskjoblog->add($a_input);

                     if (count($order->jobs) > 0) {
                        $response = $order;
                        // Inform agent we request POST method, agent will then submit result
                        // in POST request if it supports the method or it will continue with GET
                        $response->postmethod = 'POST';
                        $response->token = Session::getNewCSRFToken();
                     }
                  }
               }
            }
            break;

         case 'setAnswer':
            // example
            // ?action=setAnswer&InformationSource=0x00000000&BIOSVersion=VirtualBox&SystemManufacturer=innotek%20GmbH&uuid=fepjhoug56743h&SystemProductName=VirtualBox&BIOSReleaseDate=12%2F01%2F2006
            if (empty($uuid)) {
               return $response;
            }
            $jobstate = current($pfTaskjobstate->find(
               [
                  'uniqid' => $uuid,
                  'state'  => ['!=', PluginFusioninventoryTaskjobstate::FINISHED]
               ],
               [],
               1)
            );

            if (isset($jobstate['plugin_fusioninventory_agents_id'])) {

               $add_value = true;

               $pfAgent->getFromDB($jobstate['plugin_fusioninventory_agents_id']);
               $computers_id = $pfAgent->fields['computers_id'];

               $a_values = $_GET;
               // Check agent uses POST method to use the right submitted values. Also renew token to support CSRF for next post.
               if (isset($_GET['method']) && $_GET['method'] == 'POST') {
                  $a_values = $_POST;
                  $response->token = Session::getNewCSRFToken();
                  unset($a_values['_glpi_csrf_token']);
               }
               $sid = isset($a_values['_sid'])?$a_values['_sid']:0;
               $cpt = isset($a_values['_cpt'])?$a_values['_cpt']:0;
               unset($a_values['action']);
               unset($a_values['uuid']);
               unset($a_values['_cpt']);
               unset($a_values['_sid']);

               $this->getFromDB($jobstate['items_id']);

               switch ($this->fields['type']) {
                  case 'registry':
                     // update registry content
                     $pfCollect_subO = new PluginFusioninventoryCollect_Registry_Content();
                     break;

                  case 'wmi':
                     // update wmi content
                     $pfCollect_subO = new PluginFusioninventoryCollect_Wmi_Content();
                     break;

                  case 'file':
                     if (!empty($a_values['path']) && isset($a_values['size'])) {
                        // update files content
                        $params = [
                           'machineid' => $pfAgent->fields['device_id'],
                           'uuid'      => $uuid,
                           'code'      => 'running',
                           'msg'       => "file ".$a_values['path']." | size ".$a_values['size']
                        ];
                        if (isset($a_values['sendheaders'])) {
                           $params['sendheaders'] = $a_values['sendheaders'];
                        }
                        PluginFusioninventoryCommunicationRest::updateLog($params);
                        $pfCollect_subO = new PluginFusioninventoryCollect_File_Content();
                        $a_values = [$sid => $a_values];
                     } else {
                        $add_value = false;
                     }
                     break;
               }

               if (!isset($pfCollect_subO)) {
                  // return anyway the next CSRF token to client
                  break;
               }

               if ($add_value) {
                  // add collected informations to computer
                  $pfCollect_subO->updateComputer(
                     $computers_id,
                     $a_values,
                     $sid
                  );
               }

               // change status of state table row
               $pfTaskjobstate->changeStatus($jobstate['id'],
                        PluginFusioninventoryTaskjobstate::AGENT_HAS_SENT_DATA);

               // add logs to job
               if (count($a_values)) {
                  $flag    = PluginFusioninventoryTaskjoblog::TASK_INFO;
                  $message = json_encode($a_values, JSON_UNESCAPED_SLASHES);
               } else {
                  $flag    = PluginFusioninventoryTaskjoblog::TASK_ERROR;
                  $message = __('Path not found', 'fusioninventory');
               }
                  $pfTaskjoblog->addTaskjoblog($jobstate['id'],
                                             $jobstate['items_id'],
                                             $jobstate['itemtype'],
                                             $flag,
                                             $message);
            }
            break;

         case 'jobsDone':
            $jobstate = current($pfTaskjobstate->find(
               [
                  'uniqid' => $uuid,
                  'state'  => ['!=', PluginFusioninventoryTaskjobstate::FINISHED]
               ],
               [],
               1)
            );
            $pfTaskjobstate->changeStatusFinish(
               $jobstate['id'],
               $jobstate['items_id'],
               $jobstate['itemtype']
            );

               break;
      }
      return $response;
   }


   /**
    * After purge item, delete collect data
    */
   function post_purgeItem() {

      // Delete all registry
      $pfCollect_Registry = new PluginFusioninventoryCollect_Registry();
      $items = $pfCollect_Registry->find(['plugin_fusioninventory_collects_id' => $this->fields['id']]);
      foreach ($items as $item) {
         $pfCollect_Registry->delete(['id' => $item['id']], true);
      }

      // Delete all WMI
      $pfCollect_Wmi = new PluginFusioninventoryCollect_Wmi();
      $items = $pfCollect_Wmi->find(['plugin_fusioninventory_collects_id' => $this->fields['id']]);
      foreach ($items as $item) {
         $pfCollect_Wmi->delete(['id' => $item['id']], true);
      }

      // Delete all File
      $pfCollect_File = new PluginFusioninventoryCollect_File();
      $items = $pfCollect_File->find(['plugin_fusioninventory_collects_id' => $this->fields['id']]);
      foreach ($items as $item) {
         $pfCollect_File->delete(['id' => $item['id']], true);
      }
      parent::post_deleteItem();
   }

}