hook.php

<?php

/**
 * -------------------------------------------------------------------------
 * Escalade plugin for GLPI
 * -------------------------------------------------------------------------
 *
 * LICENSE
 *
 * This file is part of Escalade.
 *
 * Escalade is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Escalade 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Escalade. If not, see <http://www.gnu.org/licenses/>.
 * -------------------------------------------------------------------------
 * @copyright Copyright (C) 2015-2023 by Escalade plugin team.
 * @license   GPLv2 https://www.gnu.org/licenses/gpl-2.0.html
 * @link      https://github.com/pluginsGLPI/escalade
 * -------------------------------------------------------------------------
 */

/**
 * Plugin install process
 *
 * @return boolean
 */
function plugin_escalade_install() {
   global $DB;

   //init migration
   $migration = new Migration(PLUGIN_ESCALADE_VERSION);

   $default_charset = DBConnection::getDefaultCharset();
   $default_collation = DBConnection::getDefaultCollation();
   $default_key_sign = DBConnection::getDefaultPrimaryKeySignOption();

   // == Tables creation (initial installation) ==
   if (!$DB->tableExists('glpi_plugin_escalade_histories')) {
      $query = "CREATE TABLE `glpi_plugin_escalade_histories` (
         `id`              INT {$default_key_sign} NOT NULL AUTO_INCREMENT,
         `tickets_id`      INT {$default_key_sign} NOT NULL,
         `groups_id`       INT {$default_key_sign} NOT NULL,
         `date_mod`        TIMESTAMP NOT NULL,
         PRIMARY KEY (`id`),
         KEY `tickets_id` (`tickets_id`),
         KEY `groups_id` (`groups_id`)
      ) ENGINE=InnoDB DEFAULT CHARSET={$default_charset} COLLATE={$default_collation} ROW_FORMAT=DYNAMIC;";
      $DB->query($query);
   }

   if (!$DB->tableExists('glpi_plugin_escalade_configs')) {
      $query = "CREATE TABLE `glpi_plugin_escalade_configs` (
         `id`                                      INT {$default_key_sign} NOT NULL AUTO_INCREMENT,
         `remove_group`                            INT NOT NULL,
         `show_history`                            INT NOT NULL,
         `task_history`                            INT NOT NULL,
         `remove_tech`                             INT NOT NULL,
         `solve_return_group`                      INT NOT NULL,
         `reassign_group_from_cat`                 INT NOT NULL,
         `reassign_tech_from_cat`                  INT NOT NULL,
         `cloneandlink_ticket`                     INT NOT NULL,
         `close_linkedtickets`                     INT NOT NULL,
         `use_assign_user_group`                   INT NOT NULL,
         `use_assign_user_group_creation`          INT NOT NULL,
         `use_assign_user_group_modification`      INT NOT NULL,
         `remove_delete_requester_user_btn`        TINYINT NOT NULL DEFAULT 1,
         `remove_delete_watcher_user_btn`          TINYINT NOT NULL DEFAULT 1,
         `remove_delete_assign_user_btn`           TINYINT NOT NULL DEFAULT 0,
         `remove_delete_requester_group_btn`       TINYINT NOT NULL DEFAULT 1,
         `remove_delete_watcher_group_btn`         TINYINT NOT NULL DEFAULT 1,
         `remove_delete_assign_group_btn`          TINYINT NOT NULL DEFAULT 0,
         `remove_delete_assign_supplier_btn`       TINYINT NOT NULL DEFAULT 1,
         `use_filter_assign_group`                 INT NOT NULL,
         `ticket_last_status`                      INT NOT NULL,
         `remove_requester`                        INT NOT NULL,
         PRIMARY KEY (`id`)
      ) ENGINE=InnoDB DEFAULT CHARSET={$default_charset} COLLATE={$default_collation} ROW_FORMAT=DYNAMIC;";
      $DB->query($query);

      $query = "INSERT INTO glpi_plugin_escalade_configs
      VALUES (NULL, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, '".Ticket::WAITING."',0)";
      $DB->query($query);
   }

   // == Update to 1.2 ==
   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'cloneandlink_ticket')) {
      $migration->addField('glpi_plugin_escalade_configs', 'cloneandlink_ticket',
                           'integer', ['after' => 'reassign_tech_from_cat']);
      $migration->migrationOneTable('glpi_plugin_escalade_configs');
   }
   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'close_linkedtickets')) {
      $migration->addField('glpi_plugin_escalade_configs', 'close_linkedtickets',
                           'integer', ['after' => 'cloneandlink_ticket']);
      $migration->migrationOneTable('glpi_plugin_escalade_configs');
   }

   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'use_assign_user_group')) {
      $migration->addField('glpi_plugin_escalade_configs', 'use_assign_user_group',
                           'integer', ['after' => 'close_linkedtickets']);
      $migration->migrationOneTable('glpi_plugin_escalade_configs');
   }
   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'use_assign_user_group_creation')) {
      $migration->addField('glpi_plugin_escalade_configs', 'use_assign_user_group_creation',
                           'integer', ['after' => 'use_assign_user_group']);
      $migration->migrationOneTable('glpi_plugin_escalade_configs');
   }
   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'use_assign_user_group_modification')) {
      $migration->addField('glpi_plugin_escalade_configs', 'use_assign_user_group_modification',
                           'integer', ['after' => 'use_assign_user_group_creation']);
      $migration->migrationOneTable('glpi_plugin_escalade_configs');
   }
   if (! isIndex("glpi_plugin_escalade_histories", 'tickets_id')
       || ! isIndex("glpi_plugin_escalade_histories", 'groups_id')) {
      $migration->addKey("glpi_plugin_escalade_histories", 'tickets_id', 'tickets_id');
      $migration->addKey("glpi_plugin_escalade_histories", 'groups_id', 'groups_id');
      $migration->migrationOneTable('glpi_plugin_escalade_histories');
   }

   // == Update to 1.3 ==
   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'use_filter_assign_group')) {
      $migration->addField('glpi_plugin_escalade_configs', 'use_filter_assign_group',
                           'integer', ['after' => 'use_assign_user_group_modification']);
      $migration->migrationOneTable('glpi_plugin_escalade_configs');
   }
   if (!$DB->tableExists('glpi_plugin_escalade_groups_groups')) {
      $query = "CREATE TABLE `glpi_plugin_escalade_groups_groups` (
         `id` INT {$default_key_sign} NOT NULL AUTO_INCREMENT,
         `groups_id_source` int {$default_key_sign} NOT NULL DEFAULT '0',
         `groups_id_destination` int {$default_key_sign} NOT NULL DEFAULT '0',
         PRIMARY KEY (`id`)
      ) ENGINE=InnoDB DEFAULT CHARSET={$default_charset} COLLATE={$default_collation} ROW_FORMAT=DYNAMIC;";
      $DB->query($query);
   }

   // Update for 0.84 status
   if ($DB->tableExists('glpi_plugin_escalade_configs')) {
      foreach ($DB->request("glpi_plugin_escalade_configs") as $data) {
         switch ($data['ticket_last_status']) {
            case 'solved':
               $status = Ticket::SOLVED;
               break;
            case 'waiting':
               $status = Ticket::WAITING;
               break;
            case 'closed':
               $status = Ticket::CLOSED;
               break;
            case 'assign':
               $status = Ticket::ASSIGNED;
               break;
            case 'new':
               $status = Ticket::INCOMING;
               break;
            case 'plan':
               $status = Ticket::PLANNED;
               break;
            default :
               $status = -1;
               break;
         }
         $query = "UPDATE `glpi_plugin_escalade_configs`
                   SET `ticket_last_status` = '".$status."'
                   WHERE `id` = '".$data['id']."'";
         $DB->query($query);
      }

      $query = "ALTER TABLE `glpi_plugin_escalade_configs` MODIFY `ticket_last_status` INT;";
      $DB->query($query);
   }

   // update to 0.85-1.0
   if ($DB->fieldExists("glpi_plugin_escalade_configs", "assign_me_ticket")) {
      // assign me ticket feature native in glpi 0.85
      $migration->dropField("glpi_plugin_escalade_configs", "assign_me_ticket");
      $migration->migrationOneTable('glpi_plugin_escalade_configs');
   }

   // update to 0.90-1.1
   if (!$DB->tableExists('glpi_plugin_escalade_users')) {
      $query = "CREATE TABLE `glpi_plugin_escalade_users` (
                  `id` INT {$default_key_sign} NOT NULL AUTO_INCREMENT,
                  `users_id` INT {$default_key_sign} NOT NULL,
                  `use_filter_assign_group` TINYINT NOT NULL DEFAULT '0',
                  PRIMARY KEY (`id`),
                  INDEX `users_id` (`users_id`)
               )
               ENGINE=InnoDB;";
      $DB->query($query);

      include_once(Plugin::getPhpDir('escalade')."/inc/config.class.php");

      $config = new PluginEscaladeConfig();
      $config->getFromDB(1);
      $default_value = $config->fields["use_filter_assign_group"];

      $user = new User();
      foreach ($user->find() as $data) {
         $query = "INSERT INTO glpi_plugin_escalade_users (`users_id`, `use_filter_assign_group`)
                     VALUES (".$data['id'].", $default_value)";
         $DB->query($query);
      }
   }

   // ## update to 2.2.0
   // add new fields
   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'remove_delete_requester_user_btn')) {
      $migration->addField('glpi_plugin_escalade_configs', 'remove_delete_requester_user_btn',
                           'bool', ['value' => 1]);
   }
   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'remove_delete_requester_group_btn')) {
      $migration->addField('glpi_plugin_escalade_configs', 'remove_delete_requester_group_btn',
                           'bool', ['value' => 1]);
   }
   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'remove_delete_watcher_user_btn')) {
      $migration->addField('glpi_plugin_escalade_configs', 'remove_delete_watcher_user_btn',
                           'bool', ['value' => 1]);
   }
   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'remove_delete_watcher_group_btn')) {
      $migration->addField('glpi_plugin_escalade_configs', 'remove_delete_watcher_group_btn',
                           'bool', ['value' => 1]);
   }

   // migrate old fields
   if ($DB->fieldExists('glpi_plugin_escalade_configs', 'remove_delete_user_btn')) {
      $migration->changeField('glpi_plugin_escalade_configs',
                              'remove_delete_user_btn',
                              'remove_delete_assign_user_btn',
                              'bool',
                              ['value' => 0]);
   }
   if ($DB->fieldExists('glpi_plugin_escalade_configs', 'remove_delete_group_btn')) {
      $migration->changeField('glpi_plugin_escalade_configs',
                              'remove_delete_group_btn',
                              'remove_delete_assign_group_btn',
                              'bool',
                              ['value' => 0]);
   }
   if ($DB->fieldExists('glpi_plugin_escalade_configs', 'remove_delete_supplier_btn')) {
      $migration->changeField('glpi_plugin_escalade_configs',
                              'remove_delete_supplier_btn',
                              'remove_delete_assign_supplier_btn',
                              'bool',
                              ['value' => 1]);
   }

   $migration->migrationOneTable('glpi_plugin_escalade_configs');

   if ($DB->fieldExists('glpi_plugin_escalade_histories', 'previous_groups_id')) {
      $migration->changeField('glpi_plugin_escalade_histories', 'previous_groups_id', 'groups_id_previous', "INT {$default_key_sign} NOT NULL DEFAULT 0");
   }
   $migration->migrationOneTable('glpi_plugin_escalade_histories');

   if (!$DB->fieldExists('glpi_plugin_escalade_histories', 'groups_id_previous')
      || !$DB->fieldExists("glpi_plugin_escalade_histories", 'counter')) {
      if (!$DB->fieldExists('glpi_plugin_escalade_histories', 'groups_id_previous')) {
         $migration->addField('glpi_plugin_escalade_histories', 'groups_id_previous', "INT {$default_key_sign} NOT NULL DEFAULT 0", ['before' => 'groups_id']);
      }
      if (!$DB->fieldExists('glpi_plugin_escalade_histories', 'counter')) {
         $migration->addField('glpi_plugin_escalade_histories', 'counter', 'integer', ['after' => 'groups_id']);
      }
      $migration->migrationOneTable('glpi_plugin_escalade_histories');

      $history = new PluginEscaladeHistory();
      $histories = [];
      foreach ($history->find() as $data) {
         $tickets_id = $data['tickets_id'];
         unset($data['tickets_id']);

         if (!isset($histories[$tickets_id])) {
            $histories[$tickets_id] = [];
         }

         $histories[$tickets_id][] = $data;
      }

      foreach ($histories as $tickets_id => $h) {
         $counters = [];

         foreach ($h as $k => $details) {
            if (isset($h[$k+1])) {
               $first  = $h[$k+1]['groups_id'] < $details['groups_id'] ? $h[$k+1]['groups_id'] : $details['groups_id'];
               $second = $h[$k+1]['groups_id'] < $details['groups_id'] ? $details['groups_id'] : $h[$k+1]['groups_id'];

               $counters[$first][$second] = isset($counters[$first][$second]) ? $counters[$first][$second] + 1 : 1;
               $h[$k+1]['groups_id_previous'] = $details['groups_id'];
               $h[$k+1]['counter'] = $counters[$first][$second];
            }
         }

         foreach ($h as $k => $details) {
            $DB->update(
               'glpi_plugin_escalade_histories',
               ['groups_id_previous' => $details['groups_id_previous'], 'counter' => $details['counter']],
               ['id' => $details['id']]
            );
         }
      }

   }
   //Update to 2.6.3
   // add new fields
   if (!$DB->fieldExists('glpi_plugin_escalade_configs', 'remove_requester')) {
      $migration->addField('glpi_plugin_escalade_configs', 'remove_requester',
                           'integer', ['after' => 'ticket_last_status']);
      $migration->migrationOneTable('glpi_plugin_escalade_configs');
   }

   return true;
}

/**
 * Plugin uninstall process
 *
 * @return boolean
 */
function plugin_escalade_uninstall() {
   global $DB;

   //Delete plugin's table
   $tables = [
      'glpi_plugin_escalade_histories',
      'glpi_plugin_escalade_configs',
      'glpi_plugin_escalade_groups_groups',
      'glpi_plugin_escalade_users',
   ];
   foreach ($tables as $table) {
      $DB->query("DROP TABLE IF EXISTS `$table`");
   }

   return true;
}

function plugin_escalade_item_purge($item) {
   global $DB;

   if ($item instanceof User) {
      $DB->query("DELETE FROM glpi_plugin_escalade_users WHERE users_id = ".$item->getID());
   }

   if ($item instanceof Ticket) {
      $history = new PluginEscaladeHistory;
      $history->deleteByCriteria([
         'tickets_id' => $item->getID()
      ]);
   }
   return true;
}

function plugin_escalade_pre_item_update($item) {
   if ($item instanceof Ticket) {
      return PluginEscaladeTicket::pre_item_update($item);
   }
   return true;
}

function plugin_escalade_item_update($item) {
   if ($item instanceof Ticket) {
      return PluginEscaladeTicket::item_update($item);
   }
   return true;
}

function plugin_escalade_item_add_user($item) {
   global $DB;

   if ($item instanceof User) {
      $config = new PluginEscaladeConfig();
      $config->getFromDB(1);
      $default_value = $config->fields["use_filter_assign_group"];

      $query = "INSERT INTO glpi_plugin_escalade_users (`users_id`, `use_filter_assign_group`)
                  VALUES (".$item->getID().", $default_value)";
      $DB->query($query);
   }

   if ($item instanceof Ticket_User) {
      //prevent escalade hook to trigger on ticket creation
      if (isset($_SESSION['plugin_escalade']['skip_hook_add_user'])) {
         //unset($_SESSION['plugin_escalade']['skip_hook_add_user']);
         return true;
      }

      //this hook is only for assign
      if ($item->fields['type'] == CommonITILActor::ASSIGN) {
         return PluginEscaladeTicket::item_add_user($item);
      }
      if ($item->fields['type'] == CommonITILActor::REQUESTER) {
         return PluginEscaladeTicket::item_add_user($item,CommonITILActor::REQUESTER);
      }
   }
   return true;
}

function plugin_escalade_pre_item_add_ticket($item) {
   if ($item instanceof Ticket) {
      $_SESSION['plugin_escalade']['skip_hook_add_user'] = true;
   }
}

function plugin_escalade_item_add_ticket($item) {
   //clean escalade session var after ticket creation
   if ($item instanceof Ticket) {
      unset($_SESSION['plugin_escalade']['skip_hook_add_user']);
      unset($_SESSION['plugin_escalade']['keep_users']);
   }
}

function plugin_escalade_pre_item_add_group_ticket($item) {
   if ($item instanceof Group_Ticket
       && $item->input['type'] == CommonITILActor::ASSIGN) {
         //disable notification to prevent notification for old AND new group
         $item->input['_disablenotif'] = true;
      return PluginEscaladeTicket::addHistoryOnAddGroup($item);
   }
   return $item;
}

function plugin_escalade_item_add_group_ticket($item) {
   if ($item instanceof Group_Ticket
       && $item->fields['type'] == CommonITILActor::ASSIGN) {
      return PluginEscaladeTicket::processAfterAddGroup($item);
   }
   return $item;
}


function plugin_escalade_post_prepareadd_ticket ($item) {
   if ($item instanceof Ticket) {
      return PluginEscaladeTicket::assignUserGroup($item);
   }
   return $item;
}

function plugin_escalade_getAddSearchOptions($itemtype) {
   $sopt = [];

   if ($itemtype == 'Ticket') {
         $sopt[1881]['table']         = 'glpi_groups';
         $sopt[1881]['field']         = 'completename';
         $sopt[1881]['datatype']      = 'dropdown';
         $sopt[1881]['name']          = __("Group concerned by the escalation", "escalade");
         $sopt[1881]['forcegroupby']  = true;
         $sopt[1881]['massiveaction'] = false;
         $sopt[1881]['condition']     = ['is_assign' => 1];
         $sopt[1881]['joinparams']    = [
            'beforejoin' => [
               'table'      => 'glpi_plugin_escalade_histories',
               'joinparams' => [
                  'jointype'  => 'child',
                  'condition' => ''
               ]
            ]
         ];

         $sopt[] = [
            'id'                 => '1991',
            'table'              => 'glpi_plugin_escalade_histories',
            'field'              => 'id',
            'name'               => __("Number of escalations", "escalade"),
            'forcegroupby'       => true,
            'usehaving'          => true,
            'datatype'           => 'count',
            'massiveaction'      => false,
            'joinparams'         => [
               'jointype'           => 'child'
            ]
         ];

         $sopt[] = [
            'id'                 => '1992',
            'table'              => 'glpi_plugin_escalade_histories',
            'field'              => 'counter',
            'name'               => __("Number of escalations between two groups", "escalade"),
            'datatype'           => 'integer',
            'joinparams'         => [
               'jointype'           => 'child'
            ]
         ];
   }
   if ($itemtype == 'User') {
      $sopt[2150]['table']         = 'glpi_plugin_escalade_users';
      $sopt[2150]['field']         = 'use_filter_assign_group';
      $sopt[2150]['linkfield']     = 'id';
      $sopt[2150]['datatype']      = 'bool';
      $sopt[2150]['searchtype']    = ['equals'];
      $sopt[2150]['name']          = __("Enable filtering on the groups assignment", 'escalade');
      $sopt[2150]['joinparams']    = [
         'beforejoin'  => [
            'table'      => 'glpi_plugin_escalade_users',
            'joinparams' => [
               'jointype' => 'child',
               'condition' => ''
            ]
         ]
      ];
   }
   return $sopt;
}

function plugin_escalade_MassiveActions($itemtype) {
   switch ($itemtype) {
      case 'User':
         return ['PluginEscaladeUser'.MassiveAction::CLASS_ACTION_SEPARATOR.'use_filter_assign_group'
                  => __("Enable filtering on the groups assignment", 'escalade')];
   }
   return [];
}