tomolino-processmaker/inc/processmaker.class.php

<?php

if (!defined('GLPI_ROOT')) {
   die("Sorry. You can't access directly to this file");
}

/**
 * Summary of variableStruct
 *      class used to define case variables passed at case start or injected during process at any time.
 */
class variableStruct {
   public $name;
   public $value;
}

/**
 * Summary of getVariableStruct
 *      class used to get case variables at  any time during process.
 */
class getVariableStruct {
   public $name;
}


$pmHideSolution = false;


if (!function_exists('http_formdata_flat_hierarchy')) {
   /**
   * Summary of http_formdata_flat_hierarchy
   * @param mixed $data
   * @return array
   */
   function http_formdata_flat_hierarchy($data) {
      $vars=array();
      foreach ($data as $key=>$value) {
         if (is_array($value)) {
            $temp = array();
            foreach ($value as $k2 => $val2) {
               $temp[ $key.'['.$k2.']' ] = $val2;
            }
            $vars = array_merge( $vars, http_formdata_flat_hierarchy($temp) );
         } else {
            $vars[$key]=$value;
         }
      }
      return $vars;
   }

}

if (!function_exists('stripcslashes_deep')) {
   /**
   * Strip c slash  for variable & array
   *
   * @param $value     array or string: item to stripslashes (array or string)
   *
   * @return stripcslashes item
   **/
   function stripcslashes_deep($value) {

      $value = is_array($value) ?
                array_map('stripcslashes_deep', $value) :
                stripcslashes($value);

      return $value;
   }
}

/**
 * PluginProcessmakerProcessmaker short summary.
 *
 * PluginProcessmakerProcessmaker description.
 *
 * @version 1.0
 * @author MoronO
 */
class PluginProcessmakerProcessmaker extends CommonDBTM {

   var $serverURL;

   var $config;
   private $pmSoapClient = null;
   private $pmWorkspace = "";
   private $pmAdminSession = false;

   private $taskWriter = 0;
   private $pm_group_guid = ''; // guid for default user group in Process Maker is used for all GLPI user synchronization into ProcessMaker
   var $lasterror;
   var $lang;


   /**
   * Return the table used to store this object
   *
   * @return string
   **/
   static function getTable($classname = null) {

      return "glpi_plugin_processmaker_processes";
   }

   /**
   * Summary of addTicketFollowup
   * @param mixed   $itemId
   * @param mixed   $txtForFollowup
   * @param integer $users_id       optional, if null will uses logged-in user
   */
   public function addTicketFollowup( $itemId, $txtForFollowup, $users_id=null ) {
      $fu = new TicketFollowup();
      $fu->getEmpty(); // to get default values
      $input = $fu->fields;
      if (isset( $txtForFollowup['GLPI_TICKET_FOLLOWUP_CONTENT'] )) {
         $input['content']=$txtForFollowup['GLPI_TICKET_FOLLOWUP_CONTENT'];
      }
      if (isset( $txtForFollowup['GLPI_TICKET_FOLLOWUP_IS_PRIVATE'] )) {
         $input['is_private']=$txtForFollowup['GLPI_TICKET_FOLLOWUP_IS_PRIVATE'];
      }
      if (isset( $txtForFollowup['GLPI_TICKET_FOLLOWUP_REQUESTTYPES_ID'] )) {
         $input['requesttypes_id']=$txtForFollowup['GLPI_TICKET_FOLLOWUP_REQUESTTYPES_ID'];
      }
      $input['tickets_id']=$itemId;
      $input['users_id']= (isset($users_id) ? $users_id : Session::getLoginUserID( true )); // $this->taskWriter;

      $fu->add( $input );
   }


   /**
   * Summary of openSoap
   * @return true if open succeeded, and pmSoapClient is initialized
   *         false otherwise
   */
   private function openSoap( ) {

      try {
         if ($this->pmSoapClient == null) {
            $this->lang = substr( $_SESSION["glpilanguage"], 0, 2);
            if (strlen( $this->lang ) <> 2) {
               $this->lang = "en"; // by default
            }
            $this->config = PluginProcessmakerConfig::getInstance();
            $this->pmWorkspace = $this->config->fields['pm_workspace'];
            $this->serverURL = trim($this->config->fields['pm_server_URL'], '/').'/sys'.$this->config->fields['pm_workspace'].'/'.$this->lang.'/'.$this->config->fields['pm_theme'];
            $this->taskWriter = $this->config->fields['users_id'];
            $this->pm_group_guid = $this->config->fields['pm_group_guid'];
            $this->pmSoapClient = new SoapClient($this->serverURL."/services/wsdl2", array( 'soap_version'   => SOAP_1_2, 'compression' => SOAP_COMPRESSION_ACCEPT | SOAP_COMPRESSION_GZIP) );
         }

         return true;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         $this->lasterror = $e;
         return false; //null ;
      }
   }


   /**
   * Summary of login
   * @param mixed $admin_or_user if true will be admin, otherwise is user name (or user id), or current user
   * @return true if login has been correctly done with current GLPI user, or if a PM session was already open
   *         false if an exception occured (like SOAP error or PM login error)
   */
   function login( $admin_or_user=false ) {
      global $DB, $PM_DB;
      try {
         $locSession = new stdClass; // by default empty object
         if ($this->openSoap( )) {
            $cookie_lifetime = ini_get('session.cookie_lifetime');
            if ($cookie_lifetime == 0) {
               $cookie_lifetime = 15 * 60; //= 15 minutes
            }
            if ($admin_or_user === true) { // admin rights has been requested, then force new login
                $config = PluginProcessmakerConfig::getInstance();
                $locSession = $this->pmSoapClient->login( array( 'userid' => $config->fields['pm_admin_user'], 'password' => Toolbox::decrypt($config->fields['pm_admin_passwd'], GLPIKEY)) );
               if (is_object( $locSession ) && $locSession->status_code == 0) {
                  $_SESSION["pluginprocessmaker"]["session"]["admin"] = true;
                  $_SESSION["pluginprocessmaker"]["session"]["id"] = $locSession->message;
                  $_SESSION["pluginprocessmaker"]["session"]["date"] = $locSession->timestamp;
                  $this->pmAdminSession = true;
                  return true;
               }
            } else if (empty($_SESSION["pluginprocessmaker"]["session"]["date"]) || ($_SESSION["pluginprocessmaker"]["session"]["admin"] == true)
                || $this->pmAdminSession == true
                       || date_add( date_create( $_SESSION["pluginprocessmaker"]["session"]["date"] ), new DateInterval( "PT".$cookie_lifetime."S" ) ) < date_create( date( "Y-m-d H:i:s" ) ) ) {
               // get the password of the user
               $pmusr = new PluginProcessmakerUser;
               $gusr = new User;
               if (is_numeric($admin_or_user)) {
                  $gusr->getFromDB( $admin_or_user );
               } else {
                  $gusr->getFromDBbyName( $admin_or_user !== false ? $admin_or_user : $_SESSION["glpiname"]);
               }
               $pmusr->getFromDB( $gusr->getID() );
               //if (!isset($pmusr->fields['password']) || $pmusr->fields['password'] == "") {
                  $pass = md5(Toolbox::encrypt( $gusr->getID().$gusr->getName().time(), GLPIKEY) );
                  $pmusr->update( array('id' => $pmusr->getID(), 'password' => $pass) );
                  //$DB->query( "UPDATE glpi_plugin_processmaker_users SET password = '".$pass."' WHERE glpi_users_id = ".$pmusr->getID().";" ) ;
                  //$pmusr->update( array( $pmusr->getIndexName() => $pmusr->getID(), 'password' => $pass) ) ;
                  // and must be updated also in PM db
                  $PM_DB->query("UPDATE RBAC_USERS SET USR_PASSWORD='".$pass."' WHERE USR_UID='".$pmusr->fields['pm_users_id']."' ");
                  $PM_DB->query("UPDATE USERS SET USR_PASSWORD='".$pass."' WHERE USR_UID='".$pmusr->fields['pm_users_id']."' ");
               //}
               $locSession = $this->pmSoapClient->login( array( 'userid' => $gusr->fields['name'], 'password' => 'md5:'.$pmusr->fields['password']) );
               if (is_object( $locSession ) && $locSession->status_code == 0) {
                  $_SESSION["pluginprocessmaker"]["session"]["id"] = $locSession->message;
                  $_SESSION["pluginprocessmaker"]["session"]["date"] = $locSession->timestamp;
                  $_SESSION["pluginprocessmaker"]["session"]["admin"] = false;
                  $this->pmAdminSession = false;
                  return true;
               }
            } else {
               return true; // means a session is already existing in $_SESSION["pluginprocessmaker"]["session"]
            }
         }

         $this->pmAdminSession = false;
         unset($_SESSION["pluginprocessmaker"]["session"]);
         Toolbox::logDebug( "Processmaker Plugin: $admin_or_user - Soap problem: ". print_r( $locSession, true ) );
         $this->lasterror = $locSession;
         return false;
      } catch (Exception $e) {
         $this->pmAdminSession = false;
         unset($_SESSION["pluginprocessmaker"]["session"]);
         Toolbox::logDebug( $e );
         return false;
      }
   }


   /**
   * Summary of processList
   *      Returns list of processes
   *      Embedded processList() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#processList.28.29)
   *      A session must be open before with login()
   *      Normalizes output to an array, even when only one element is returned by PM
   * @return an array of processListStruct objects
   */
   function processList( ) {
      try {
         $pmProcessList = $this->pmSoapClient->processList( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"]) );
         if (isset( $pmProcessList->processes )) {
            if (is_array( $pmProcessList->processes )) {
               return $pmProcessList->processes;
            } else {
               return array( 0 => $pmProcessList->processes );
            }
         }

         return false;

      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of getCaseInfo
   *      returns information about a given case (as long as the logged in user has privileges to access the case).
   *      Embedded getCaseInfo() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#getCaseInfo.28.29)
   *      A session must be open before with login()
   *      Normalizes output of currentUsers to an array, even when only one element is returned by PM,
   *      Note: currentUsers field doesn't exist when case is CANCELLED
   * @param $caseId: The case ID, which can be obtained with the caseList() function
   * @param $delIndex: The delegation index, which is a positive integer to identify the current task of the case. If empty then use current delIndex.
   * @return a getCaseInfoResponse object, or false exception occured
   */
   function getCaseInfo( $caseId, $delIndex='') {
      try {
         $pmCaseInfo = $this->pmSoapClient->getCaseInfo( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'caseId' => $caseId, 'delIndex' => $delIndex) );
         switch ($pmCaseInfo->caseStatus) {
            case 'DRAFT' :
            case 'TO_DO':
               //                case 'CANCELLED' :
               if (is_object( $pmCaseInfo->currentUsers )) {
                   $pmCaseInfo->currentUsers = array( 0 => $pmCaseInfo->currentUsers );
               }
               if ($pmCaseInfo->currentUsers[0]->delThreadStatus == 'PAUSE') {
                   $pmCaseInfo->caseStatus = "PAUSED";
               }
                break;
         }
         return $pmCaseInfo;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }

   }

   /**
   * Summary of routeCase
   *       routes a case (i.e., moves the case to the next task in the process according to its routing rules).
   *       Embedded routeCase() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#routeCase.28.29)
   *       A session must be open before with login()
   * @param $caseId The case ID, which can be obtained with the caseList() function
   * @param $delIndex The delegation index, which is a positive integer to identify the current task of the case. If empty then use current delIndex.
   * @return a routeCaseResponse object, or false exception occured. routing is normalized to be always an array of routeListStruct
   */
   function routeCase( $caseId, $delIndex) {
      try {
         $pmRouteCaseResponse = $this->pmSoapClient->routeCase( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'caseId' => $caseId, 'delIndex' => $delIndex) );
         if ($pmRouteCaseResponse->status_code != 0) {
             Toolbox::logDebug( 'routeCase res:', $pmRouteCaseResponse );
         }

         if (property_exists( $pmRouteCaseResponse, 'routing' ) && is_object( $pmRouteCaseResponse->routing )) {
             $pmRouteCaseResponse->routing = array( 0 => $pmRouteCaseResponse->routing);
         }

         return $pmRouteCaseResponse;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of triggerList
   *      Returns list of triggers
   *      Embedded triggerList() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#triggerList.28.29)
   *      A session must be open before with login()
   *      Normalizes output to an array, even when only one element is returned by PM
   * @return an array of triggerListStruct objects, or false when exception occured
   */
   function triggerList( ) {
      try {
         $pmTriggerList = $this->pmSoapClient->triggerList( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"]) );
         if (is_array(  $pmTriggerList->triggers  )) {
             return  $pmTriggerList->triggers;
         } else {
            return array( 0 => $pmTriggerList->triggers );
         }
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of taskList
   *      Returns list of tasks to which the logged-in user is assigned
   *      Embedded taskList() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#taskList.28.29)
   *      A session must be open before with login()
   *      Normalizes output to an array, even when only one element is returned by PM
   * @return an array of taskListStruct objects, or false when exception occured
   */
   function taskList( ) {
      try {
         $pmTaskList = $this->pmSoapClient->taskList( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"]) );

         if (is_array(  $pmTaskList->tasks  )) {
             return  $pmTaskList->tasks;
         } else {
            return array( 0 => $pmTaskList->tasks );
         }
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }


   /**
   * Summary of taskCase
   *      Returns list of tasks to which the logged-in user is assigned
   *      Embedded taskList() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#taskList.28.29)
   *      A session must be open before with login()
   *      Normalizes output to an array, even when only one element is returned by PM
   * @return array of taskListStruct objects, or false when exception occured
   */
   function taskCase( $caseId ) {
      try {
         $pmTaskCase = $this->pmSoapClient->taskCase( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'caseId' => $caseId ) );

         if (is_array(  $pmTaskCase->taskCases  )) {
             return  $pmTaskCase->taskCases;
         } else {
            return array( 0 => $pmTaskCase->taskCases );
         }
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of claimCase
   * @param mixed $caseId
   * @param mixed $delIndex
   * @return mixed
   */
   function claimCase( $caseId, $delIndex) {
      try {
         $pmClaimCase = $this->pmSoapClient->claimCase( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'guid' => $caseId, 'delIndex' => $delIndex) );
         return $pmClaimCase;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of unpauseCase
   *      Unpauses a specified case.
   *      Embedded UnpauseCase() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#UnpauseCase.28.29)
   *      A session must be open before with login()
   *      Normalizes output to an array, even when only one element is returned by PM
   * @param $caseId The unique ID of the case.
   * @param $delIndex The delegation index of the current task in the case.
   * @param $userId The unique ID of the user who will unpause the case.
   * @return an array of UnpauseCaseStruct, or false when exception occured
   */
   function unpauseCase( $caseId, $delIndex, $userId ) {
      try {
         $pmUnpauseCase = $this->pmSoapClient->unpauseCase( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'caseUid' => $caseId, 'delIndex' => $delIndex, 'userUid' => $userId) );

         if (is_array( $pmUnpauseCase->processes )) {
             return  $pmUnpauseCase->processes;
         } else {
            return array( 0 => $pmUnpauseCase->processes );
         }
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of caseList
   *      returns a list of the cases for the logged-in user.
   *      Embedded caseList() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#caseList.28.29)
   *      A session must be open before with login()
   *      Normalizes output to an array, even when only one element is returned by PM
   * @return an array of cases, or false when exception occured
   */
   function caseList( ) {
      try {
         $pmCaseList = $this->pmSoapClient->caseList( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"]) );

         if (is_array(  $pmCaseList->cases  )) {
             return  $pmCaseList->cases;
         } else {
            return array( 0 => $pmCaseList->cases );
         }
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
    * Summary of systemInformation
    *      returns information about the PM system
    *      Embedded systemInformation() PM web service call (definition: http://wiki.processmaker.com/index.php/ProcessMaker_WSDL_Web_Services#systemInformation.28.29)
    *      A session must be open before with login()
    * @return an object containing information, or false when exception occured
    */
   function systemInformation( ) {
      try {
         $pmSystemInfo = $this->pmSoapClient->systemInformation( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"]) );
         return $pmSystemInfo;
      }
      catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of reassignCase
   *      reassigns a case to a different user. Note that the logged-in user needs to have the PM_REASSIGNCASE permission in his/her role in order to be able to reassign the case.
   *      Embedded caseList() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#reassignCase.28.29)
   *      A session must be open before with login()
   * @param $caseId The case ID, which can be obtained with the caseList() function.
   * @param $delIndex The current delegation index number of the case, which can be obtained with the caseList() function.
   * @param $userIdSource The user who is currently assigned the case, which can be obtained with the caseList() function.
   * @param $userIdTarget The target user who will be newly assigned to the case, which can be obtained with userList(). The case can only be reassigned to a user who is one of the assigned users or ad-hoc users to the current task in the case.
   * @return A pmResponse object, or false when exception occured
   */
   function reassignCase( $caseId, $delIndex, $userIdSource, $userIdTarget ) {
      try {
         $pmResults = $this->pmSoapClient->reassignCase( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'caseId' => $caseId, 'delIndex' => $delIndex, 'userIdSource' => $userIdSource, 'userIdTarget'=> $userIdTarget) );
         return $pmResults;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }


   /**
   * Summary of deleteCase
   *      Deletes a case
   *      Embedded deleteCase() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#deleteCase.28.29)
   *      A session must be open before with login()
   *      Beware that at any time you may delete a case!!!
   * @param $caseUid The case ID, which can be obtained with the caseList() function.
   * @return A deleteCaseResponse object, or false when exception occured
   */
   function deleteCase( $caseUid ) {
      try {
         $deleteCaseResponse = $this->pmSoapClient->deleteCase( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'caseUid' => $caseUid) );
         return $deleteCaseResponse;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }


   /**
   * Summary of cancelTask
   *      Cancels a task
   *      Embedded cancelCase() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#cancelCase.28.29)
   *      A session must be open before with login()
   *      Beware that this will only cancel the task with delIndex
   *           in the case of // tasks you must call cancelTask for each running task.
   *           in the case of one and only one task running, then it will cancel the case
   * @param $caseUid The case ID, which can be obtained with the caseList() function.
   * @param $delIndex The delegation index of the current task in the case.
   * @param $userUid: The unique ID of the user who will unpause the case.
   * @return A cancelCaseResponse object, or false when exception occured
   */
   function cancelTask( $caseUid, $delIndex, $userUid ) {
      try {
         $cancelTaskResponse = $this->pmSoapClient->cancelCase( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'caseUid' => $caseUid, 'delIndex' => $delIndex, 'userUid' => $userUid) );
         return $cancelTaskResponse;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }


   /**
   * Summary of cancelCase
   *      Cancels a case
   *      Embedded cancelCase() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#cancelCase.28.29)
   *      A session must be open before with login()
   *      Beware that this will cancel all running task
   *           in the case of // tasks you must call cancelCase for each running task.
   *           in the case of one and only one task is running, then it will cancel the case
   * @param $caseUid The case ID, which can be obtained with the caseList() function.
   * @param $delIndex The delegation index of the current task in the case.
   * @param $userUid: The unique ID of the user who will unpause the case.
   * @return A cancelCaseResponse object, or false when exception occured
   */
   function cancelCase( $caseUid ) {
      try {
         $pmCaseInfo = $this->getCaseInfo( $caseUid );
         if ($pmCaseInfo->status_code == 0) {
            foreach ($pmCaseInfo->currentUsers as $pmUser) {
               $pmCancelTask = $this->cancelTask( $caseUid, $pmUser->delIndex, $pmUser->userId );
               if ($pmCancelTask->status_code != 0) {
                   return $pmCancelTask;
               }
            }
         }
         return $pmCancelTask;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }


   /**
   * Summary of newCaseImpersonate
   *      Starts a new case under the name of the logged-in user.
   *      The task that will be started is the default one (=must be unique in process definition)!
   *      logged-in user must be assigned to this task, otherwise use newCaseImpersonate() to start the case.
   *      New case is started with DRAFT status.
   *      Embedded newCaseImpersonate() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#newCaseImpersonate.28.29)
   *      A session must be open before with login(), in order to call this function.
   * @param $processId The ID of the process where the case should start, which can be obtained with processList()
   * @param $userId The ID of the user who initiates the case, which can be obtained with userList().
   * @param $vars an array of associative variables (name => value) that will be injected into the case as case variables
   * @return A newCaseResponse object, or false when exception occured
   */
   function newCaseImpersonate( $processId, $userId, $vars = null ) {
      try {
         $this->getFromDB( $processId );

         if ($vars !== null) {
            $aVars = array();
            foreach ($vars as $key => $val) {
               $obj = new variableStruct();
               $obj->name = $key;
               $obj->value = $val;
               $aVars[] = $obj;
            }
         } else {
            $aVars = '';
         }

         $newCaseResponse = $this->pmSoapClient->newCaseImpersonate( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'processId'=> $this->fields['process_guid'], 'userId' => $userId, 'taskId'=>'', 'variables'=> $aVars) );
         return $newCaseResponse;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of newCase
   *      Starts a new case under the name of the logged-in user.
   *      The task that will be started is the default one (=must be unique in process definition)!
   *      logged-in user must be assigned to this task, otherwise use newCaseImpersonate() to start the case.
   *      New case is started with DRAFT status.
   *      Embedded newCase() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#newCase.28.29)
   *      A session must be open before with login()
   * @param string $processId The ID of the process which will be instantied into a case, which can be obtained with processList()
   * @param array  $vars      an array of associative variables (name => value) that will be injected into the case as case variables
   * @return A newCaseResponse object, or false when exception occured
   */
   function newCase( $processId, $vars = array() ) {
      try {
         $this->getFromDB( $processId );

         $aVars = array();
         foreach ($vars as $key => $val) {
            $obj = new variableStruct();
            $obj->name = $key;
            $obj->value = $val;
            $aVars[] = $obj;
         }

         $newCaseResponse = $this->pmSoapClient->newCase( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'processId'=> $this->fields['process_guid'], 'taskId'=>'', 'variables'=> $aVars) );

         return $newCaseResponse;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of sendVariables
   *      Sends variables to a case.
   *      Embedded sendVariables() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#sendVariables.28.29)
   *      A session must be open before with login()
   * @param string $caseId The uID of the case
   * @param array  $vars   an array of associative variables (name => value) that will be injected into the case as case variables
   * @return A pmResponse object, or false when exception occured
   */
   function sendVariables( $caseId, $vars = array() ) {
      if (count( $vars ) == 0) { // nothing to send
          return true;
      }
      try {
         $aVars = array();
         foreach ($vars as $key => $val) {
            $obj = new variableStruct();
            $obj->name = $key;
            if (is_array( $val )) {
                $obj->value = join( "|", $val );
            } else {
               $obj->value = $val;
            }
            $aVars[] = $obj;
         }

         $pmResponse = $this->pmSoapClient->sendVariables( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'caseId' => $caseId, 'variables'=> $aVars) );

         return $pmResponse;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }



   /**
   * Summary of getVariables
   *      Gets variables from a case.
   *      Embedded getVariables() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#getVariables.28.29)
   *      A session must be open before with login()
   * @param string $caseId The uID of the case
   * @param array  $vars   an array of variable name that will be read from the case as case variables Normalizes output to an array, even when only one element is returned by PM Normalizes output to an array, even when only one element is returned by PM
   *      Normalizes output to an array, even when only one element is returned by PM
   * @return array: an associative array (variable_name => value), or false when exception occured. The return array can be empty if requested variables are not found.
   */
   function getVariables( $caseId, $vars = array() ) {
      try {
         $aVars = array();
         foreach ($vars as $key => $name) {
            $obj = new getVariableStruct();
            $obj->name = $name;
            $aVars[] = $obj;
         }

         $pmvariableListResponse = $this->pmSoapClient->getVariables( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'caseId' => $caseId, 'variables'=> $aVars) );

         $variablesArray = array();

         if ($pmvariableListResponse->status_code == 0 && isset( $pmvariableListResponse->variables )) {
            if (is_array( $pmvariableListResponse->variables )) {
               foreach ($pmvariableListResponse->variables as $variable) {
                   $variablesArray[$variable->name] = $variable->value;
               } } else {
               $variablesArray[$pmvariableListResponse->variables->name] = $pmvariableListResponse->variables->value;
               }
         }

         return $variablesArray;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of groupList
   *      returns a list of the groups. For privileges to see the list, the logged-in user must have the PM_USERS permission in his/her role.
   *      Embedded groupList() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#groupList.28.29)
   *      A session must be open before with login()
   *      Normalizes output to an array, even when only one element is returned by PM
   * @return an array of groupListStruct, or false when exception occured
   */
   function groupList( ) {
      try {
         $pmGroupList = $this->pmSoapClient->groupList( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"]) );

         if (is_array(  $pmGroupList->groups  )) {
             return  $pmGroupList->groups;
         } else {
            return array( 0 => $pmGroupList->groups );
         }
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of assignUserToGroup
   *      assigns a user to a group. For privileges to assign a user, the logged-in user must have the PM_USERS permission in his/her role.
   *      Embedded assignUserToGroup() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#assignUserToGroup.28.29)
   *      A session must be open before with login()
   * @param $userId a Processmaker user id (see userList())
   * @param $groupId a Processmaker group id (see groupList())
   * @return A pmResponse object, or false when exception occured
   */
   function assignUserToGroup( $userId, $groupId) {
      try {
         $pmResults = $this->pmSoapClient->assignUserToGroup(array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"],
                                                             'userId' => $userId,
                                                             'groupId' => $groupId
                                                             ) );
         return $pmResults;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   *  Summary of createGroup
   *      creates a new group. For privileges to create a group, the logged-in user must have the PM_USERS permission in his/her role.
   *      group will be created as 'ACTIVE'
   *      Embedded createGroup() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#createGroup.28.29)
   *      A session must be open before with login()
   * @param $name: the name of the group to be created
   * @return A pmResponse object, or false when exception occured
   */
   function createGroup( $name ) {
      try {
         $pmResults = $this->pmSoapClient->createGroup(array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"],
                                                             'name' => $name ) );
         return $pmResults;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of updateGroup
   *      updates group directly into Processmaker DB
   * @param $group_id: guid of the pm group
   * @param $groupStatus: new status to be set to $group_id, could be 'ACTIVE' or 'INACTIVE'
   * @return true if group status has been modified, false otherwise
   */
   function updateGroup( $group_id, $groupStatus ) {
      global $PM_DB;
      $query = "UPDATE GROUPWF SET GRP_STATUS='$groupStatus' WHERE GRP_UID='$group_id';";
      $PM_DB->query( $query );
      if ($PM_DB->affected_rows != 1) {
          return false;
      } else {
         return true;
      }
   }

   /**
   * Summary of userList
   *      returns a list of the Processmaker users. For privileges to see the list, the logged-in user must have the PM_USERS permission in his/her role.
   *      Embedded userList() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#userList.28.29)
   *      A session must be open before with login()
   *      Normalizes output to an array, even if only one element is returned by PM
   * @return an array of userListStruct, or false when exception occured
   */
   function userList( ) {
      try {
         $pmUserList = $this->pmSoapClient->userList( array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"]) );

         if (is_array(  $pmUserList->users  )) {
             return  $pmUserList->users;
         } else {
            return array( 0 => $pmUserList->users );
         }
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of createUser
   *      creates a new user. For privileges to create a user, the logged-in user must have the PM_USERS permission in his/her role.
   *      Embedded createUser() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#createUser.28.29)
   *      A session must be open before with login()
   * @param $userId The username for the new user. The unique ID for the user will be automatically generated. Is the user Windows login!
   * @param $firstname The user's first name. If empty (== null or == "") will default to $userId.
   * @param $lastname The user's last name. If empty (== null or == "") will default to $userId.
   * @param $email The user's email address. If empty (== null or == "") will default to $userId@DoNotReply.com.
   * @param $role The user's role, such as 'PROCESSMAKER_ADMIN', 'PROCESSMAKER_MANAGER' or 'PROCESSMAKER_OPERATOR'. Possible values can be looked up with the roleList() function.
   * @param $password The user's password, such as 'Be@gle2'. (It will be automatically converted into an MD5 hash when inserted in the database.)
   * @param $status The user's status, such as "ACTIVE", "INACTIVE".
   * @return returns a createUserResponse object, or false if exception occurred
   */
   function createUser( $userId, $firstname, $lastname, $email, $role, $password, $status) {
      try {
         if ($firstname == null || $firstname == "") {
            $firstname = $userId;
         }
         if ($lastname == null || $lastname == "") {
            $lastname = $userId;
         }
         if ($email == "") {
            $email = $userId."@DoNotReply.com";
         }

         $pmResults = $this->pmSoapClient->createUser(array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"],
                                                             'userId' => $userId,
                                                             'firstname'=> $firstname,
                                                             'lastname' => $lastname,
                                                             'email' => $email,
                                                             'role' => $role,
                                                             'password' => $password,
                                                             'status' => $status ) );
         return $pmResults;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }


   /**
   * Summary of updateUser
   *      updates user information.
   *      Embedded updateUser() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#updateUser.28.29)
   *      A session must be open before with login()
   * @param $userUid the unique Id for the user (Processmaker user id)
   * @param $userName is the user logon. IT IS STRONGLY ADVISE NOT TO CHANGE THIS INFORMATION
   * @param $firstname The user's first name. If empty (== null or == "") will default to $userName.
   * @param $lastname The user's last name. If empty (== null or == "") will default to $userName.
   * @param $status The user's status, such as "ACTIVE", "INACTIVE".
   * @return returns a UpdateUserResponse  object, or false if exception occurred
   */
   function updateUser( $userUid, $userName, $firstName, $lastName, $status) {
      try {
         if ($firstName == null || $firstName == "") {
            $firstName = $userName;
         }
         if ($lastName == null || $lastName == "") {
            $lastName = $userName;
         }

         $pmResults = $this->pmSoapClient->updateUser(array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"],
                                                             'userUid' => $userUid,
                                                             'userName' => $userName,
                                                             'firstName'=> $firstName,
                                                             'lastName' => $lastName,
                                                             'status' => $status
                                                             ) );
         return $pmResults;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }

   /**
   * Summary of executeTrigger
   *      executes a ProcessMaker trigger.
   *      Note that triggers which are tied to case derivation will be executed automatically, so this function does not need to be called when deriving cases.
   *      Embedded executeTrigger() PM web service call (definition: http://wiki.processmaker.com/index.php/2.0/ProcessMaker_WSDL_Web_Services#executeTrigger.28.29)
   *      A session must be open before with login()
   * @param $caseId The case ID, which is can be found with caseList().
   * @param $triggerIndex The ID of the trigger to execute, which can be found with triggerList().
   * @param $delIndex The delegation index number of the case, which can be found with caseList().
   * @return A pmResponse object. If successful, the message will contain "executed: <TRIGGER_CODE>". Otherwise false in case of SOAP error
   */
   function executeTrigger( $caseId, $triggerIndex, $delIndex ) {
      try {
         $pmResults = $this->pmSoapClient->executeTrigger(array( 'sessionId' => $_SESSION["pluginprocessmaker"]["session"]["id"], 'caseId' => $caseId, 'triggerIndex'=> $triggerIndex, 'delIndex' => $delIndex ) );
         return $pmResults;
      } catch (Exception $e) {
         Toolbox::logDebug( $e );
         return false;
      }
   }



   /**
   * summary of cronInfo
   *      Gives localized information about 1 cron task
   * @param $name of the task
   * @return array of strings
   */
   static function cronInfo($name) {
      global $LANG;

      switch ($name) {
         case 'pmusers' :
             return array('description' => $LANG['processmaker']['cron']['pmusers'] );
         case 'pmorphancases' :
            return array('description' => $LANG['processmaker']['cron']['pmorphancases']['description'], 'parameter' => $LANG['processmaker']['cron']['pmorphancases']['parameter']  );
         case 'pmtaskactions' :
            return array('description' => $LANG['processmaker']['cron']['pmtaskactions'] );
      }
      return array();
   }

   /**
   * summary of cronPMTaskActions
   *       Execute 1 task managed by the plugin
   * @param: $task CronTask class for log / stat
   * @return integer
   *    >0 : done
   *    <0 : to be run again (not finished)
   *     0 : nothing to do
   */
   static function cronPMTaskActions($task) {
      global $DB, $PM_DB;

      $usr = false; // by default
      if (!isset($PM_DB)) {
         $PM_DB = new PluginProcessmakerDB;

         // also create a GLPI session with the processmaker task writer
         $usr = new User;
         $config = PluginProcessmakerConfig::getInstance();
         $usr->getFromDB($config->fields['users_id']);
         $save_session = $_SESSION;
         $usr->loadMinimalSession(0, true);
         $_SESSION['glpiparententities'] = [];
      }

      $actionCode = 0; // by default
      $error = false;
      $task->setVolume(0); // start with zero

      $pm = new self;
      $existingpmsession = isset($_SESSION["pluginprocessmaker"]["session"]);
      $formerusers_id = 0;
      // get the list of taskactions to be done
      foreach ($DB->request( getTableForItemType('PluginProcessmakerCrontaskaction'), ' `state` = '.PluginProcessmakerCrontaskaction::DATA_READY ) as $taskaction) {

         try {

            if ($formerusers_id != $taskaction['users_id']) {
               unset($_SESSION["pluginprocessmaker"]["session"]); // to reset previous user login if any
            }

            $pm->login($taskaction['users_id']);

            $postdata = json_decode($taskaction['postdata'], true);

            // must filter arrays as arrays are grids and index must start at 1 instead of 0 like in json
            foreach($postdata['form'] as &$field) {
               if (is_array($field)) {
                  if (count($field) > 0){
                     // then must reindex the array starting to 1 instead of 0
                     array_unshift($field, '');
                     unset($field[0]);
                  } else {
                     $field[] = "";
                  }
               }
            }

            if ($taskaction['is_targettoclaim']) {
               // must do a claim before solving task
               if (!$pm->claimCase( $postdata['APP_UID'], $postdata['DEL_INDEX'] )) {
                  throw new Exception("Can't claim case");
               }

               // do not send notifications
               $donotif = self::saveNotification(false);

               // now manage tasks associated with item
               $pm->claimTask( $postdata['APP_UID'], $postdata['DEL_INDEX'], $taskaction['users_id'] );

               self::restoreNotification($donotif);

            }
            $myCase = new PluginProcessmakerCase;
            if ($myCase->getFromDB( $postdata['APP_UID'] )) {

               //$cookies = json_decode($taskaction['cookies'], true) ;
               $pm->derivateCase( $myCase, $postdata, $taskaction['users_id'] );
            }

            $tkaction = new PluginProcessmakerCrontaskaction;
            $tkaction->update( array( 'id' => $taskaction['id'], 'state' => PluginProcessmakerCrontaskaction::DONE ) );

            $task->addVolume(1);
            $task->log( "Applied task action id: '".$taskaction['id']."'" );

         } catch (Exception $e) {
            $task->log( "Can't apply task action id: '".$taskaction['id']."'" );
            $error = true;
         }

         $formerusers_id = $taskaction['users_id'];
      }

      if ($existingpmsession) {
         unset($_SESSION["pluginprocessmaker"]["session"]); // reset the one created during the foreach
         if (!Session::isCron()) {
            $pm->login(); // re-log default user
         }
      }

      if ($usr) {
         // restore previous session
         Session::destroy();
         Session::start();
         $_SESSION = $save_session;
      }

      if ($error) {
         return -1;
      } else {
         return $actionCode;
      }

   }
   /**
   * summary of cronPMOrphanCases
   *       Execute 1 task managed by the plugin
   * @param: $task CronTask class for log / stat
   * @return integer
   *    >0 : done
   *    <0 : to be run again (not finished)
   *     0 : nothing to do
   */
   static function cronPMOrphanCases($task) {
      global $PM_DB, $DB;

      if (!isset($PM_DB)) {
         $PM_DB = new PluginProcessmakerDB;
      }

      // get list of case assigned to GLPi items
      $draftCases = array(0);
      $query = "SELECT case_num FROM glpi_plugin_processmaker_cases WHERE case_status = 'DRAFT';";
      foreach ($DB->request( $query ) as $row) {
         $draftCases[] = $row['case_num'];
      }

      $actionCode = 0; // by default
      $error = false;
      $task->setVolume(0); // start with zero

      if (count($draftCases) > 0) {
         $pm = new self;
         $pm->login(true);
         $query = "SELECT * FROM APPLICATION
                  WHERE APP_DATA LIKE '%s:24:\"GLPI_SELFSERVICE_CREATED\";s:1:\"1\"%'
                     AND APP_STATUS = 'DRAFT'
                     AND DATEDIFF( NOW(), APP_UPDATE_DATE) > ".$task->fields['param']."
                     AND APP_NUMBER NOT IN (".implode(',', $draftCases).");
                ";
         foreach ($PM_DB->request( $query ) as $row) {
            $ret = $pm->deleteCase( $row['APP_UID'] );
            $task->addVolume(1);
            if ($ret !== false) {
               $task->log( "Deleted case num: '".$row['APP_NUMBER']."'" );
               $actionCode = 1;
            } else {
               $task->log( "Can't delete case num: '".$row['APP_NUMBER']."'" );
               $error = true;
            }
         }
      }
      if ($error) {
         return -1;
      } else {
         return $actionCode;
      }

   }


   /**
   * summary of cronPMUsers
   *       Executes 1 task managed by the plugin
   * @param $task CronTask class for log / stat
   * @return integer
   *    >0 : done
   *    <0 : to be run again (not finished)
   *     0 : nothing to do
   */
   static function cronPMUsers($task) {
      global $DB, $PM_DB;

      if (!isset($PM_DB)) {
         $PM_DB = new PluginProcessmakerDB;
      }

      $actionCode = 0; // by default
      $error = false;
      $task->setVolume(0); // start with zero

      // start a processmaker session
      $myProcessMaker = new PluginProcessmakerProcessmaker();
      if (!$myProcessMaker->login( true )) {
         $task->log( "Error PM: '".print_r($myProcessMaker->lasterror, true)."'" );
         return -1;
      }

      $pmGroupList = $myProcessMaker->groupList( );
      foreach ($pmGroupList as $pmGroup) {
         if ($pmGroup->guid == $myProcessMaker->pm_group_guid) {
            break; // to get the name :)
         }
      }

      $pmUserList = array();
      foreach ($myProcessMaker->userList() as $pmuser) {
         $pmUserList[ strtolower($pmuser->name)] = array( 'name' => $pmuser->name, 'guid' => $pmuser->guid,  'status' => $pmuser->status );
      }

      // get the complete user list from GLPI DB
      $glpiUserList = array();
      foreach ($DB->request("SELECT glpi_users.id, glpi_users.name, glpi_users.realname, glpi_users.firstname, glpi_users.is_active, glpi_users.is_deleted, glpi_plugin_processmaker_users.pm_users_id as pmUserId
                              FROM glpi_users
                              LEFT JOIN glpi_plugin_processmaker_users on glpi_plugin_processmaker_users.id = glpi_users.id
                              WHERE name not like '*%'") as $dbgroup) {
         $glpiUserList[ strtolower($dbgroup['name'])] = $dbgroup;
      }

      $arrayDiff = array_diff_key( $glpiUserList, $pmUserList );

      foreach ($arrayDiff as $user) {
         if ($user['is_active'] != 0 && $user['is_deleted'] != 1) {
            $status = "ACTIVE";
            $task->addVolume(1);
            $pass = substr( Toolbox::encrypt($user['id'].$user['name'].time(), GLPIKEY), 0, 20);
            $pmResult = $myProcessMaker->createUser( $user['name'], $user['firstname'], $user['realname'], "", "PROCESSMAKER_OPERATOR", $pass, $status);
            if ($pmResult->status_code == 0) {
               $task->log( "Added user: '".$user['name']."'" );

               // then assign user to group
               $pmResult2 = $myProcessMaker->assignUserToGroup( $pmResult->userUID, $pmGroup->guid );
               if ($pmResult2->status_code == 0) {
                   $task->log( "Added user: '".$user['name']."' to '".$pmGroup->name."' group" );
               } else {
                  $task->log( "Error PM: '".$pmResult2->message."'" );
               }

               // insert into DB the link between glpi users and pm user
               $pmuser = new PluginProcessmakerUser;
               if ($pmuser->getFromDB( $user['id'] )) {
                  $pmuser->update( array( 'id' => $user['id'], 'pm_users_id' => $pmResult->userUID, 'password' => md5( $pass ) ) );
               } else {
                  $pmuser->add( array( 'id' => $user['id'], 'pm_users_id' => $pmResult->userUID, 'password' => md5( $pass ) ) );
               }
               $actionCode = 1;

            } else {
               $task->log( "Error adding user: '".$user['name']."'" );
               $task->log( "Error PM: '".$pmResult->message."'" );
               $actionCode = -1;
               $error = true;
            }
         } else {
            unset( $glpiUserList[$user['name']] );
         }
      }

      if (!$error) {

         // now should refresh the existing users
         $arrayIntersect = array_intersect_key( $glpiUserList, $pmUserList );
         foreach ($arrayIntersect as $user) {
            if ($user['pmUserId'] == null || ($user['pmUserId'] != $pmUserList[strtolower($user['name'])]['guid'])) { //must be inserted into DB
               // insert into DB the link between glpi users and pm user
               $pmuser = new PluginProcessmakerUser;
               if ($pmuser->getFromDB( $user['id'] )) {
                  $ret = $pmuser->update( array( 'id' => $user['id'], 'pm_users_id' => $pmUserList[strtolower($user['name'])]['guid'] ) );
               } else {
                  $ret = $pmuser->add( array( 'id' => $user['id'], 'pm_users_id' => $pmUserList[strtolower($user['name'])]['guid'] ) );
               }

               //$query = "REPLACE INTO glpi_plugin_processmaker_users (glpi_users_id, pm_users_id) VALUES (".$user['id'].", '". $pmUserList[strtolower($user['name'])]['guid']."');" ;
               //$DB->query( $query ) or
               if (!$ret) {
                  $task->log( "Cannot update user: '".$user['id']."' into glpi_plugin_processmaker_users!" );
               }

            }
            if ($user['is_active'] == 0 || $user['is_deleted'] == 1) {
                $status = "INACTIVE";
            } else {
               $status = "ACTIVE";
            }
            if ($status != $pmUserList[strtolower($user['name'])]['status']) {
               $task->addVolume(1);
               $pmResult = $myProcessMaker->updateUser( $pmUserList[strtolower($user['name'])]['guid'], $user['name'], $user['firstname'], $user['realname'], $status );
               if ($pmResult->status_code == 0) {
                  $task->log( "Updated user: '".$user['name']."', status: '".$pmUserList[strtolower($user['name'])]['status']."' -> '".$status."'" );
                  $actionCode = 1;
               } else {
                  $task->log( "Error updating user: '".$user['name']."'" );
                  $task->log( "Error PM: '".$pmResult->message."'" );
                  $actionCode = -1;
                  $error = true;
               }
            }

         }
      }

      // now we should desactivate PM users who are not in glpi user list
      //if( !$error ) {
      //    $status = "INACTIVE" ;
      //    $arrayDiff = array_diff_key( $pmUserList , $glpiUserList ) ;
      //    foreach( $arrayDiff as $user ){
      //        $task->addVolume(1);
      //        if( $user['status'] == 'ACTIVE' && $user['name'] != 'admin' && $user['name'] != 'glpi'){
      //            $pmResult = $myProcessMaker->updateUser( $user['guid'], $user['name'], null, null, $status ) ;
      //            if( $pmResult->status_code == 0) {
      //                $task->log( "Updated user: '".$user['name']."', status: '".$user['status']."' -> '".$status."'" ) ;
      //                $actionCode = 1 ;
      //            } else {
      //                $task->log( "Error updating user: '".$user['name']."'" ) ;
      //                $task->log( "Error PM: '".$pmResult->message."'" ) ;
      //                $actionCode = -1 ;
      //                $error = true ;
      //            }
      //        }
      //    }
      //}

      // so now treat GLPI groups
      $glpiGroupList = array();
      foreach ($DB->request("SELECT id, name, is_task, is_usergroup FROM glpi_groups WHERE is_task=1 AND is_usergroup=1") as $dbgroup) {
         $glpiGroupList[$dbgroup['name']] = $dbgroup;
      }

      $pmGroupList = self::getPMGroups(); // array();

      // here we can compare group lists like done for the users
      $arrayDiff = array_diff_key( $glpiGroupList, $pmGroupList );

      // then for each group we must check if it exists, and if not create a real PM group
      foreach ($arrayDiff as $group) {
         // it is not existing in PM
         // then create
         $pmResult = $myProcessMaker->createGroup( $group['name'] );
         if ($pmResult->status_code == 0) {
            $task->addVolume(1);
            $task->log( "Added group: '".$group['name']."'" );
         }
      }

      // review and update all users in each group
      $pmGroupList = self::getPMGroups(); // array();

      // now should refresh the existing users into groups
      $arrayDiff = array_intersect_key( $glpiGroupList, $pmGroupList );
      foreach ($arrayDiff as $group) {
         // for each group will delete users and re-create them
         // not really optimized, but this way we are sure that groups are synchronized
         // must be redesigned
         $query = "DELETE FROM GROUP_USER WHERE GROUP_USER.GRP_UID='".$pmGroupList[$group['name']]['CON_ID']."';";
         $PM_DB->query( $query );
         // and insert all users from real GLPI group
         foreach ($DB->request("SELECT glpi_groups_users.users_id, glpi_plugin_processmaker_users.pm_users_id
                                   FROM glpi_groups
                                   JOIN glpi_groups_users ON glpi_groups_users.groups_id=glpi_groups.id
                                   JOIN glpi_plugin_processmaker_users ON glpi_plugin_processmaker_users.id=glpi_groups_users.users_id
                                   WHERE glpi_groups.name='".$group['name']."'") as $user ) {
            $query = "INSERT INTO GROUP_USER (`GRP_UID`, `USR_UID`) VALUES ( '".$pmGroupList[$group['name']]['CON_ID']."', '".$user['pm_users_id']."' )";
            $PM_DB->query( $query );
         }
         $task->addVolume(1);
         $task->log( "Updated users into PM group: '".$group['name']."'" );
      }

      // now should renew the duedate of the users
      $PM_DB->query("UPDATE USERS SET USR_DUE_DATE='2035-12-31' WHERE USR_DUE_DATE<>'2035-12-31'; ");
      $PM_DB->query("UPDATE RBAC_USERS SET USR_DUE_DATE='2035-12-31' WHERE USR_DUE_DATE<>'2035-12-31'; ");

      if ($error) {
          return -1;
      } else {
         return $actionCode;
      }
   }


   public static function plugin_pre_item_add_processmaker($parm) {
      global $PM_DB;

      if (isset($parm->input['processmaker_caseid'])) {
         // a case is already started for this ticket, then change ticket title and ticket type and ITILCategory

         $myProcessMaker = new PluginProcessmakerProcessmaker( );
         $myProcessMaker->login( );
         $caseInfo = $myProcessMaker->getCaseInfo( $parm->input['processmaker_caseid'], $parm->input['processmaker_delindex']);
         $parm->input['name'] = $PM_DB->escape($caseInfo->caseName );

         $caseInitialDueDate = $myProcessMaker->getVariables(  $parm->input['processmaker_caseid'], array( 'GLPI_ITEM_TITLE', 'GLPI_ITEM_INITIAL_DUE_DATE' ));
         if (array_key_exists( 'GLPI_ITEM_INITIAL_DUE_DATE', $caseInitialDueDate )) {
            $parm->input['due_date'] = $caseInitialDueDate[ 'GLPI_ITEM_INITIAL_DUE_DATE' ]." 23:59:59";
         }
         $txtItemTitle = $caseInfo->caseName;
         if (array_key_exists( 'GLPI_ITEM_TITLE', $caseInitialDueDate )) {
            $txtItemTitle = $caseInitialDueDate[ 'GLPI_ITEM_TITLE' ];
            // reset those variables
            $resultSave = $myProcessMaker->sendVariables( $parm->input['processmaker_caseid'], array( "GLPI_ITEM_TITLE" => '') );
         }
         $parm->input['name'] = $PM_DB->escape($txtItemTitle );

         $procDef = new PluginProcessmakerProcess;
         $procDef->getFromDBbyExternalID( $caseInfo->processId );
         if (isset($parm->input['type'])) {
            $parm->input['type'] = $procDef->fields['type'];
         }

         if (isset($parm->input['itilcategories_id'])) {
            $parm->input['itilcategories_id'] = $procDef->fields['itilcategories_id'];
         }

      }
   }

   public static function plugin_item_add_processmaker($parm) {
      global $DB, $GLOBALS;

      if (isset($parm->input['processmaker_caseid'])) {
         // a case is already started for this ticket, then bind them together
         $itemType = $parm->getType();
         $itemId = $parm->fields['id'];
         $caseId = $parm->input['processmaker_caseid'];

         $myCase = new PluginProcessmakerCase;

         //can't use std add due to forced case id
         $process = new PluginProcessmakerProcess;
         $process->getFromDBbyExternalID( $parm->input['processId'] );
         $query = "INSERT INTO glpi_plugin_processmaker_cases (items_id, itemtype, id, case_num, processes_id) VALUES ($itemId, '$itemType', '$caseId', ".$parm->input['processmaker_casenum'].", '".$process->getID()."');";
         $res = $DB->query($query);

         $myCase->getFromDB( $caseId ); // reloads case from DB

         $myProcessMaker = new PluginProcessmakerProcessmaker( );
         $myProcessMaker->login( );

         $caseInfo = $myProcessMaker->getCaseInfo(  $myCase->getID(), $parm->input['processmaker_delindex']);

         // here we create a fake task that will be used to store the creator of the case
         // this is due for traceability only
         $myProcessMaker->add1stTask( $myCase->fields['itemtype'], $myCase->fields['items_id'], $caseInfo, array( 'notif' => false) ); // no notif

         // before routing, send items_id and itemtype
         // as this information was not available at case creation
         $resultSave = $myProcessMaker->sendVariables( $myCase->getID(), array( "GLPI_TICKET_ID" => $itemId ) );

         // route case
         $pmRouteCaseResponse = $myProcessMaker->routeCase( $myCase->getID(), $parm->input['processmaker_delindex'] );

         // gets new case status
         $caseInfo = $myProcessMaker->getCaseInfo(  $myCase->getID(), $parm->input['processmaker_delindex']);
         // now manage tasks associated with item
         // create new tasks
         if (property_exists( $pmRouteCaseResponse, 'routing' )) {
            // now tries to get some variables to setup content for new task and to append text to solved task
            $txtForTasks = $myProcessMaker->getVariables( $myCase->getID(), array( "GLPI_ITEM_APPEND_TO_TASK",
                                                                                  "GLPI_ITEM_SET_STATUS",
                                                                                  "GLPI_TICKET_FOLLOWUP_CONTENT",
                                                                                  "GLPI_TICKET_FOLLOWUP_IS_PRIVATE",
                                                                                  "GLPI_TICKET_FOLLOWUP_REQUESTTYPES_ID" ) );
            $itemSetStatus = '';
            if (array_key_exists( 'GLPI_ITEM_SET_STATUS', $txtForTasks )) {
               $itemSetStatus = $txtForTasks[ 'GLPI_ITEM_SET_STATUS' ];
            }
            if (array_key_exists( 'GLPI_ITEM_APPEND_TO_TASK', $txtForTasks )) {
               $txtToAppendToTask = $txtForTasks[ 'GLPI_ITEM_APPEND_TO_TASK' ];
            } else {
               $txtToAppendToTask  = '';
            }
            $createFollowup = false; // by default
            if (array_key_exists( 'GLPI_TICKET_FOLLOWUP_CONTENT', $txtForTasks ) && $txtForTasks[ 'GLPI_TICKET_FOLLOWUP_CONTENT' ] != '') {
               $createFollowup = true;
            }

            // reset those variables
            $resultSave = $myProcessMaker->sendVariables( $myCase->getID(), array( "GLPI_ITEM_APPEND_TO_TASK" => '',
                                                                                   "GLPI_ITEM_SET_STATUS" => '',
                                                                                   "GLPI_TICKET_FOLLOWUP_CONTENT" => '',
                                                                                   "GLPI_TICKET_FOLLOWUP_IS_PRIVATE" => '',
                                                                                   "GLPI_TICKET_FOLLOWUP_REQUESTTYPES_ID" => '' ) );

            // routing has been done, then solve 1st task
            $myProcessMaker->solveTask(  $myCase->getID(), $parm->input['processmaker_delindex'], array( 'txtToAppend' => $txtToAppendToTask, 'notif' => false) );

            // create a followup if requested
            if ($createFollowup && $itemType == 'Ticket') {
               $myProcessMaker->addTicketFollowup( $itemId, $txtForTasks );
            }

            // and create GLPI tasks for the newly created PM tasks.
            foreach ($pmRouteCaseResponse->routing as $route) {
               $myProcessMaker->addTask( $myCase->fields['itemtype'],
                                      $myCase->fields['items_id'],
                                      $caseInfo, $route->delIndex,
                                      PluginProcessmakerUser::getGLPIUserId( $route->userId ),
                                      0,
                                      $route->taskId );
            }

            if ($itemSetStatus != '') {
               $myProcessMaker->setItemStatus($myCase->fields['itemtype'], $myCase->fields['items_id'], $itemSetStatus );
            }
         }

         // evolution of case status: DRAFT, TO_DO, COMPLETED, CANCELLED
         $myCase->update( array( 'id' => $myCase->getID(), 'case_status' => $caseInfo->caseStatus ) );
      } else {//if( array_key_exists('_head', $parm->input) ) {
              // this ticket have been created via email receiver.
         $ptnProcessToStart = "/##TicketProcess:\s*#([0-9a-f]{32})\s*##/i";
         $str = $parm->input['content'];
         if (preg_match($ptnProcessToStart, $str, $matches) > 0) {
            // and it is requested to start a case of process
            $processId = $matches[1];
            $hasCase = self::getCaseIdFromItem( 'Ticket', $parm->fields['id'] );
            if ($hasCase === false && $processId > 0) {
               // check writer
               $writer = new User;
               $writer->getFromDB( $parm->fields['users_id_recipient'] );
               $myProcessMaker = new PluginProcessmakerProcessmaker();
               $myProcessMaker->login( $writer->fields['name'] );
               $locProcess = new PluginProcessmakerProcess;
               if ($locProcess->getFromDBbyExternalID( $processId )) {
                  $found = false;
                  // check rights of writer to start this $processId on the Ticket entity
                  foreach (Profile_User::getUserProfiles( $writer->getID() ) as $profID) {
                     if (in_array( $parm->fields['entities_id'], PluginProcessmakerProcess::getEntitiesForProfileByProcess( $locProcess->getID(), $profID, true) )) {
                        $found=true;
                        break;
                     }
                  }
                  if ($found) {
                     $resultCase = $myProcessMaker->startNewCase( $locProcess->getID(), 'Ticket', $parm->fields['id'], $writer->getID()  );
                  }
               }
            }
         }
      }
      return;
   }


   public static function plugin_pre_item_add_processmaker_followup($parm) {
      //global $DB ;

   }


/**
   * Summary of addWatcher
   * add $techId as watcher to $glpi_item when techId has no rights on it
   * @param string  $itemType is the type of the CommonITILObject
   * @param integer $itemId   is the id of the ITIL object
   * @param integer $techId   is the users_id to be added
   * @return boolean true if added,
   */
   public static function addWatcher( $itemType, $itemId, $techId ) {
      if ($techId && $itemType != '' && $itemId > 0) {
         $glpi_item = getItemForItemtype( $itemType );
         $glpi_item->getFromDB( $itemId );

         // then we should check if this user has rights on the item, if not then we must add it to the watcher list!
         $glpi_item = getItemForItemtype( $itemType );
         $glpi_item->getFromDB( $itemId );
         if (!$glpi_item->isUser( CommonITILActor::REQUESTER, $techId )
               && !$glpi_item->isUser( CommonITILActor::OBSERVER, $techId )
               && !$glpi_item->isUser( CommonITILActor::ASSIGN, $techId ) ) {

            // then we must add this tech user to watcher list
            $glpi_item_user = getItemForItemtype( $glpi_item->getType() . "_User" );

            // do not send notifications
            $donotif = self::saveNotification(false);
            $glpi_item_user->add( array( $glpi_item::getForeignKeyField() => $glpi_item->getId(), 'users_id' => $techId, 'type' => CommonITILActor::OBSERVER, '_disablenotif' => true ) );
            self::restoreNotification($donotif);
            return true;
         }
      }
      return false;
   }



   /**
   * Summary of addTask
   *      adds a GLPI task to given item
   * @param $itemType string item type to which a task will be added
   * @param $itemId integer item id to which a task will be added
   * @param $caseInfo mixed getCaseInfoResponse object (see: getCaseInfo() function)
   * @param $delIndex integer index of the delegation
   * @param $techId integer GLPI user id to which a task must be assigned, if == 0 will use $groupId and/or $pmTaskId
   * @param groupId string PM group guid to assign to task, used when                      $techId  == 0
   * @param pmTaskId string PM task guid, used when                                        $groupId == 0 AND $techID == 0
   * @param $options array of options, default values are
   *            'txtTaskContent' => '',
   *            'start_date'     => '',
   *            'end_date'       => '',
   *            'notif'          => true
   * @return
   */
   public function addTask( $itemType, $itemId,  $caseInfo, $delIndex, $techId, $groupId, $pmTaskId, $options=array() ) {
      global $DB, $PM_DB, $LANG, $_SESSION;

      $default_options = array(
        'txtTaskContent' => '',
        'start_date'     => '',
        'end_date'       => '',
        'notif'          => true
        );
      foreach ($default_options as $key => $opt) {
         if (!isset($options[$key])) {
            $options[$key] = $opt;
         }
      }

      $glpi_task = getItemForItemtype( "{$itemType}Task" );
      $glpi_task->getEmpty();

      $input = array(); // will contain all data for the Task

      $input[getForeignKeyFieldForItemType($itemType)] = $itemId;
      // search for task category
      //
      $pmtaskcat = new PluginProcessmakerTaskCategory;
      $pmtaskcat->getFromDBbyExternalID( $pmTaskId );
      $input['taskcategories_id'] = $pmtaskcat->fields['taskcategories_id'];
      // load process information
      $pmProcess = new PluginProcessmakerProcess;
      $pmProcess->getFromDB( $pmtaskcat->fields['processes_id'] );

      if ($options['start_date'] == '') {
         $options['start_date'] = new DateTime( $_SESSION["glpi_currenttime"] );
      } else {
         $options['start_date'] = new DateTime( $options['start_date'] );
      }

      $input['begin'] = $options['start_date']->format("Y-m-d H:i:s");

      if ($options['end_date'] == '' || $options['end_date'] <= $input['begin']) {
         $options['end_date'] = clone $options['start_date'];
         $options['end_date']->add( new DateInterval('PT15M') );
      } else {
         $options['end_date'] = new DateTime( $options['end_date'] );
      }
      $input['end'] = $options['end_date']->format("Y-m-d H:i:s");
      $input['plan']['begin'] = $input['begin'];
      $temp = $options['start_date']->diff( $options['end_date'] );
      $input['plan']['_duration'] = $temp->d * DAY_TIMESTAMP + $temp->h * HOUR_TIMESTAMP + $temp->i * MINUTE_TIMESTAMP + $temp->s;
      if ($input['plan']['_duration'] == 0) {
         $input['plan']['_duration'] = 60; // at least
      }

      $input['users_id'] = $this->taskWriter;

      // manage groups
      if ($techId == 0) { // then we must look-up DB to get the pseudo-group that will be assigned to the task
         $groupname='';
         if ($groupId == 0) {
            $query = "SELECT CONTENT.CON_VALUE FROM TASK_USER
                            JOIN CONTENT ON CONTENT.CON_ID=TASK_USER.USR_UID AND CONTENT.CON_CATEGORY='GRP_TITLE' AND CONTENT.CON_LANG = 'en'
                            WHERE TASK_USER.TAS_UID='$pmTaskId' AND TASK_USER.TU_RELATION=2 LIMIT 1;";
         } else {
            $query = "SELECT CON_VALUE FROM CONTENT
                            WHERE CONTENT.CON_ID='$groupId' AND CONTENT.CON_CATEGORY='GRP_TITLE' AND CONTENT.CON_LANG='en' ;";
         }
         // as there is a LIMIT of 1
         // or
         // as there is only one group per guid
         // then we should have at maximun 1 record
         foreach ($PM_DB->request($query) as $onlyrec) {
            $groupname = $onlyrec['CON_VALUE'];
         }

         $groups_id_tech = 0;
         $query = "SELECT id AS glpi_group_id FROM glpi_groups WHERE name LIKE '$groupname';";
         $res = $DB->query($query);
         if ($DB->numrows($res) > 0) {
            $row = $DB->fetch_array( $res );
            $groups_id_tech = $row['glpi_group_id'];
         }

      } else {
         // adds the user tech to ticket watcher if neccessary
         self::addWatcher( $itemType, $itemId, $techId );
      }

      // manage task description
      $input['content'] = ""; // by default empty :)

      if ($pmProcess->fields["insert_task_comment"]) {
         $input['content'] .= $LANG['processmaker']['item']['task']['comment']."\n";
      }

      if ($options['txtTaskContent'] != '') {
         $input['content'] .= $options['txtTaskContent']."\n";
      } else if (!$pmProcess->fields["hide_case_num_title"]) {
         $input['content'] .= $LANG['processmaker']['item']['task']['case'].$caseInfo->caseName."\n";
      }

      $input['content'] .= $LANG['processmaker']['item']['task']['manage'];

      $input['is_private'] = 0;
      $input['actiontime'] = 0;
      $input['state'] = 1; // == TO_DO
      $input['users_id_tech'] = 0; // by default as it can't be empty
      if ($techId) {
         $input['users_id_tech'] = $techId;
      } else if ($groups_id_tech) {
         $input['groups_id_tech'] = $groups_id_tech;
      }

      $donotif = self::saveNotification($options['notif']);
      $glpi_task->add( Toolbox::addslashes_deep( $input ) );
      self::restoreNotification($donotif);

      if ($glpi_task->getId() > 0) {
         // stores link to task in DB
         $query = "INSERT INTO glpi_plugin_processmaker_tasks (items_id, itemtype, case_id, del_index) VALUES (".$glpi_task->getId().", '".$glpi_task->getType()."', '".$caseInfo->caseId."', ".$delIndex.");";
         $DB->query( $query );
      }
   }


   private static function saveNotification($donotif) {
      global $CFG_GLPI;
      // $CFG_GLPI["use_notifications"] is available since 9.2
      $savenotif = isset($CFG_GLPI["use_notifications"]) ? $CFG_GLPI["use_notifications"] : $CFG_GLPI["use_mailing"];
      if (!$donotif) {
         isset($CFG_GLPI["use_notifications"]) ? $CFG_GLPI["use_notifications"] = false : $CFG_GLPI["use_mailing"] = false;
      }
      return $savenotif;
   }


   private static function restoreNotification($savenotif) {
      global $CFG_GLPI;
      // $CFG_GLPI["use_notifications"] is available since 9.2
      isset($CFG_GLPI["use_notifications"]) ? $CFG_GLPI["use_notifications"] = $savenotif : $CFG_GLPI["use_mailing"] = $savenotif;
   }

   /**
   * Summary of add1stTask
   *      adds a GLPI task to ticket
   * @param $intemType string itemtype of object (Ticket, Problem, ....)
   * @param $itemId integer item id to which a task will be added
   * @param $caseInfo mixed getCaseInfoResponse object (see: getCaseInfo() function)
   * @param $options array of options, defaults are:
   *           'txtTaskContent' => '', is content of the task
   *           'userId'         => false, is user id to be assigned to task
   *           'notif'          => true, if true notifications will be sent
   * @return
   */
   public function add1stTask ( $itemType, $itemId, $caseInfo, $options=array() ) {

      $default_options = array(
        'txtTaskContent' => '',
        'userId'         => false,
        'notif'          => true
        );
      foreach ($default_options as $key => $opt) {
         if (!isset($options[$key])) {
            $options[$key] = $opt;
         }
      }
      $start_date = new DateTime( $_SESSION["glpi_currenttime"] );
      $official_date_time = $_SESSION["glpi_currenttime"];
      $_SESSION["glpi_currenttime"] = $start_date->sub(new DateInterval("PT1S"))->format("Y-m-d H:i:s");
      $userId = $options['userId'] ? $options['userId'] : Session::getLoginUserID();
      unset($options['userId']); // unset it as it's not in the options of addTask

      $this->addTask( $itemType,
                      $itemId,
                      $caseInfo,
                      $caseInfo->currentUsers[0]->delIndex,
                      $userId,
                      0,
                      $caseInfo->currentUsers[0]->taskId,
                      $options
                   );
      $_SESSION["glpi_currenttime"] = $official_date_time;
   }


   /**
    * Summary of setItemStatus
    * @param mixed $itemtype
    * @param mixed $itemId
    * @param mixed $newstatus
   */
   public function setItemStatus( $itemtype, $itemId, $newstatus ) {
      $item = getItemForItemtype( $itemtype );
      if ($item->getFromDB( $itemId )) { //&& $itemtype::isAllowedStatus( $item->fields['status'], $newstatus )) {
          //$item->fields['status'] = $newstatus ;
         $item->update( array('id' => $itemId, 'status' => $newstatus) );
      }
   }


   /**
    * Summary of setItemTitle
    * @param mixed $itemtype
    * @param mixed $itemId
    * @param mixed $newtitle
    */
   public function setItemTitle( $itemtype, $itemId, $newtitle ) {
      $item = getItemForItemtype( $itemtype );
      if ($item->getFromDB( $itemId )) {
         $item->update( ['id' => $itemId, 'name' => $txtItemTitle] );
      }
   }


   /**
    * Summary of setItemSolution
    * @param mixed $itemType 
    * @param mixed $itemId 
    * @param mixed $casevariablevalues 
    */
   public function setItemSolution($itemType, $itemId, $casevariablevalues) {
      $item = getItemForItemtype( $itemType );
      if ($item->getFromDB( $itemId )) {
         // default values
         $solutiontemplates_id = 0;
         $solutiontypes_id = 0;
         $solution = '';

         // check solution template
         if (array_key_exists( 'GLPI_ITEM_SET_SOLUTION_TEMPLATE_ID', $casevariablevalues )
            && $casevariablevalues[ 'GLPI_ITEM_SET_SOLUTION_TEMPLATE_ID' ] != ''
            && $casevariablevalues[ 'GLPI_ITEM_SET_SOLUTION_TEMPLATE_ID' ] != 0) {
            // get template
            $template = new SolutionTemplate;
            $template->getFromDB($casevariablevalues[ 'GLPI_ITEM_SET_SOLUTION_TEMPLATE_ID' ]);
            $entities = $template->isRecursive() ? getSonsOf(Entity::getTable(), $template->getEntityID()) : [$template->getEntityID()];
            // and check entities
            if (in_array($item->getEntityID(), $entities)) {
               $solutiontemplates_id = $template->getID();
               $solutiontypes_id = $template->fields['solutiontypes_id'];
               $solution = $template->fields['content'];
            }
         }

         // check solution type
         if (array_key_exists( 'GLPI_ITEM_SET_SOLUTION_TYPE_ID', $casevariablevalues )
            && $casevariablevalues[ 'GLPI_ITEM_SET_SOLUTION_TYPE_ID' ] != ''
            && $casevariablevalues[ 'GLPI_ITEM_SET_SOLUTION_TYPE_ID' ] != 0) {
            // get solution type
            $type = new SolutionType;
            $type->getFromDB($casevariablevalues[ 'GLPI_ITEM_SET_SOLUTION_TYPE_ID' ]);
            $entities = $type->isRecursive() ? getSonsOf(Entity::getTable(), $type->getEntityID()) : [$type->getEntityID()];
            // and check entities
            if (in_array($item->getEntityID(), $entities)) {
               $solutiontypes_id = $type->getID();
            }
         }

         // Check solution description
         if (array_key_exists( 'GLPI_ITEM_APPEND_TO_SOLUTION_DESCRIPTION', $casevariablevalues )
            && $casevariablevalues[ 'GLPI_ITEM_APPEND_TO_SOLUTION_DESCRIPTION' ] != '') {
            if ($solution != '') {
               $solution .= "\n";
            }
            $solution .= $casevariablevalues[ 'GLPI_ITEM_APPEND_TO_SOLUTION_DESCRIPTION' ] ;
         }

         $item->update( ['id' => $itemId, 'solutiontemplates_id' => $solutiontemplates_id, 'solutiontypes_id' => $solutiontypes_id, 'solution' => $solution] );
      }
   }


   /**
    * Summary of computeTaskDuration
    * @param mixed $task
    * @param mixed $entity
    * @return mixed
    */
   function computeTaskDuration( $task, $entity ) {

      if (isset($task->fields['id']) && !empty($task->fields['begin'])) {
         $calendars_id = Entity::getUsedConfig('calendars_id', $entity);
         $calendar     = new Calendar();

         // Using calendar
         if ($calendars_id>0 && $calendar->getFromDB($calendars_id)) {
            return max(0, $calendar->getActiveTimeBetween($task->fields['begin'],
                                                   $_SESSION["glpi_currenttime"]));
         }
         // Not calendar defined
         return max(0, strtotime($_SESSION["glpi_currenttime"])-strtotime($task->fields['begin']));
      }
      return 0;
   }

   /**
    * Summary of reassignTask
    * @param mixed $caseId
    * @param mixed $delIndex
    * @param mixed $newDelIndex
    * @param mixed $newTech
   */
   public function reassignTask ( $caseId, $delIndex, $newDelIndex, $newTech) {
      global $DB;

      $query = "SELECT * FROM glpi_plugin_processmaker_tasks WHERE case_id='$caseId' and del_index=$delIndex; ";
      $res = $DB->query($query);
      if ($DB->numrows($res) > 0) {
         $row = $DB->fetch_array( $res );
         $glpi_task = new $row['itemtype'];
         $glpi_task->getFromDB( $row['items_id'] );

         $itemType = str_replace( 'Task', '', $row['itemtype'] );
         $foreignkey = getForeignKeyFieldForItemType( $itemType );

         self::addWatcher( $itemType, $glpi_task->fields[ $foreignkey ], $newTech );

         $glpi_task->update( array( 'id' => $row['items_id'], $foreignkey => $glpi_task->fields[ $foreignkey ],  'users_id_tech' => $newTech ));

         // this is now done into GLPI core
         //if( !$user_can_view ) {
         //    // to cheat the entity rigths, passes default user_entity to raiseEvent(), to be sure that task_tech will receive a notification.
         //    // drawback: notifications that are entity based could be missing.
         //    // tip: $user_entities[0] is the user's default entity
         //    NotificationEvent::raiseEvent('update_task', $glpi_item, array( 'entities_id' => $user_entities[0], 'task_id' => $glpi_task->getId(), 'is_private' => 0 ) ) ;
         //}

         // then update the delIndex
         $query = "UPDATE glpi_plugin_processmaker_tasks SET del_index = $newDelIndex WHERE case_id='$caseId' and del_index=$delIndex; ";
         $res = $DB->query($query);
      }
   }

   /**
    * Summary of solveTask
    * @param string $caseId
    * @param int    $delIndex
    * @param array  $options
    *                'txtToAppend' => ''   : text to append to solved task
    *                'notif'       => true : if true will send notifications
    *                'users_id_tech'   => is the users_id of the tech that solved the task
   */
   public function solveTask( $caseId, $delIndex, $options=array() ) {
      global $DB;

      // change current glpi_currenttime to be sure that date_mode for solved task will not be identical than date_mode of the newly started task
      $start_date = new DateTime( $_SESSION["glpi_currenttime"] );
      $official_date_time = $_SESSION["glpi_currenttime"];
      $_SESSION["glpi_currenttime"] = $start_date->sub(new DateInterval("PT1S"))->format("Y-m-d H:i:s");

      $default_options = array(
        'txtToAppend' => '',
        'notif'       => true,
        'users_id_tech' => null
        );
      foreach ($default_options as $key => $opt) {
         if (!isset($options[$key])) {
            $options[$key] = $opt;
         }
      }

      $query = "SELECT * FROM glpi_plugin_processmaker_tasks WHERE case_id='$caseId' and del_index=$delIndex; ";
      $res = $DB->query($query);
      if ($DB->numrows($res) > 0) {
         $row = $DB->fetch_array( $res );

         $glpi_task = new $row['itemtype'];
         $glpi_task->getFromDB( $row['items_id'] );
         $hostItem = getItemForItemtype( $glpi_task->getItilObjectItemType() );
         $itemFKField = getForeignKeyFieldForItemType( $glpi_task->getItilObjectItemType() );
         $hostItem->getFromDB( $glpi_task->fields[ $itemFKField ] );
         $duration = $this->computeTaskDuration( $glpi_task, $hostItem->fields['entities_id'] );
         if ($options['txtToAppend'] != "") {
            $options['txtToAppend'] = "\n<hr>".$options['txtToAppend'];
         }
         $params = array( 'id' => $row['items_id'],
                        'state' => 2,
                        'end' => $_SESSION["glpi_currenttime"],
                        $itemFKField => $hostItem->getID(),
                        'actiontime' => $duration,
                        'users_id_tech' => (isset($options['users_id_tech']) ? $options['users_id_tech'] : Session::getLoginUserID()),
                        'groups_id_tech' => 0,
                        'content' => $DB->escape($glpi_task->fields[ 'content' ].$options['txtToAppend'])
                        );
         $donotif = self::saveNotification($options['notif']);
         $glpi_task->update( $params );
         self::restoreNotification($donotif);
      }

      // restore current glpi time
      $_SESSION["glpi_currenttime"] = $official_date_time;

   }

   /**
    * Summary of claimTask
    * will unassign group, and assign tech
    * @param mixed $caseId
    * @param mixed $delIndex
    * @param mixed $users_id_tech optional is the id of the tech
    *                  who's claimed the task, default current logged-in user
   */
   public function claimTask( $caseId, $delIndex, $users_id_tech=null ) {
      global $DB;

      $query = "SELECT * FROM glpi_plugin_processmaker_tasks WHERE case_id='$caseId' and del_index=$delIndex; ";
      $res = $DB->query($query);
      if ($DB->numrows($res) > 0) {
         $row = $DB->fetch_array( $res );
         $glpi_task = new $row['itemtype'];
         $glpi_task->getFromDB( $row['items_id'] );

         $itemType = str_replace( 'Task', '', $row['itemtype'] );
         $glpi_item = getItemForItemtype( $itemType );
         $glpi_item->getFromDB( $glpi_task->fields[ getForeignKeyFieldForItemType( $itemType ) ] );

         $glpi_task->update( array( 'id' => $row['items_id'],
                                    $glpi_item->getForeignKeyField() => $glpi_item->getId(),
                                    'users_id_tech' => (isset($users_id_tech)?$users_id_tech: Session::getLoginUserID()),
                                    'groups_id_tech' => 0 ));
      }
   }


    /**
     * Summary of getCaseIdFromItem
     *      get case id for an id item_id of type item_type (if a case if attached to it)
     * @param string  $item_type, the type for the item ("Ticket", "Problem", ...)
     * @param integer $item_id,   the id for the item
     * @return string the case guid, false if no case is attached to item, or if an error occurred
     */
   public static function getCaseIdFromItem ($item_type, $item_id ) {
      global $DB;

      $query = "SELECT * FROM glpi_plugin_processmaker_cases WHERE `itemtype` = '$item_type' AND `items_id` = $item_id ;";
        $res = $DB->query($query);
      if ($DB->numrows($res) > 0) {
         // case is existing for this ticket
         // then get info from db
         $row = $DB->fetch_array($res);

         return $row['id'];
      }

      return false;
   }

    /**
     * Summary of getCaseFromItem
     *      get case infos for an id item_id of type item_type (if a case if attached to it)
     * @param string  $item_type, the type for the item ("Ticket", "Problem", ...)
     * @param integer $item_id,   the id for the item
     * @return getCaseInfoResponse object, false if no case is attached to item, or if an error occurred
     */
   public function getCaseFromItem( $item_type, $item_id ) {
      global $DB;

      $caseId = self::getCaseIdFromItem( $item_type, $item_id );
      if ($caseId !== false) {
         $caseInfo = $this->getCaseInfo( $caseId );
         if ($caseInfo !== false && $caseInfo->status_code == 0) {
             return $caseInfo;
         } else {
            return false; // means any error
         }
      } else {
         return false; // means no case
      }
   }

    /**
     * Summary of multiexplode
     * @param $delimiters
     * @param $string
     * @return
     */
   static function multiexplode($delimiters, $string) {

      $ready = str_replace($delimiters, $delimiters[0], $string);
      $launch = explode($delimiters[0], $ready);
      return  $launch;
   }

   /**
   * Summary of pre_show_item_processmakerticket
   * @param $params
   */
   public static function pre_show_item_processmakerticket($params) {

      if (!is_array($params['item']) && is_subclass_of( $params['item'], 'CommonITILTask')) {
         // must check if Task is bound to a PM task
         $pmTask = new PluginProcessmakerTask($params['item']->getType());
         if ($pmTask->getFromDBByQuery("WHERE itemtype='".$params['item']->getType()."' and items_id=".$params['item']->getId())) {
            $params['item']->fields['can_edit'] = false; // to prevent task edition

            // replace ##ticket.url##_PluginProcessmakerCase$processmakercases by a setActiveTab to the Case panel
            $taskCat = new TaskCategory;
            $taskCat->getFromDB( $params['item']->fields['taskcategories_id'] );
            $taskComment = isset($taskCat->fields['comment']) ? $taskCat->fields['comment'] : '';
            if (Session::haveTranslations('TaskCategory', 'comment')) {
               $params['item']->fields['content'] = str_replace( '##processmaker.taskcomment##',
                  DropdownTranslation::getTranslatedValue( $taskCat->getID(), 'TaskCategory', 'comment', $_SESSION['glpilanguage'], $taskComment ), $params['item']->fields['content'] );
            } else {
               $params['item']->fields['content'] = str_replace( '##processmaker.taskcomment##', $taskComment, $params['item']->fields['content'] );
            }
            $taskJSId = "viewitem".$params['item']->getType().$params['item']->getId().$params['options']['rand'];

            // special case for <hr> which will provoke the rendering to be split into several <p>
            // add <p></p> which othervise will be missing
            if (stripos($params['item']->fields['content'], '<hr>') !== false) {
               $params['item']->fields['content'] = str_ireplace('<hr>', '<hr><p>', $params['item']->fields['content']).'</p>';
            }

            echo Html::scriptBlock( "
                  $('#$taskJSId').find('.item_content').children().not('.read_more').on('click', function ( ) {
                     //debugger;
                     var tabindex = $('#tabspanel').next('div').find('a[href*=\"_glpi_tab=PluginProcessmaker\"]').parent().index();
                     $('#tabspanel').next('div').tabs( 'option', 'active', tabindex );
                  } ).css('cursor', 'pointer') ;
                 ");

            $params['item']->fields['content'] = str_replace( "\n##ticket.url##_PluginProcessmakerCase\$processmakercases", "", $params['item']->fields['content'] );

            if (isset( $params['item']->fields['tr_id'] )) {
               $trID = $params['item']->fields['tr_id'];
            }
         }
      }
   }

    /**
     * Summary of pre_show_tab_arbehaviours
     * @param array $params info about tab to be shown
     * @return void
     */
   static function pre_show_tab_processmaker($params) {
      global $LANG, $pmHideSolution;
      $plugin = new Plugin();
      $itemtype = $params['item']->getType();
      switch ($itemtype) {
         case 'Ticket':
         case 'Problem':
         case 'Change':
            if ($params['options']['id']) {
               // then we are in an ITIL Object
               if (isset($_SESSION['glpiactiveprofile']['interface']) && $_SESSION['glpiactiveprofile']['interface'] != "helpdesk") {
                  $tabnum = $params['options']['tabnum'];
                  // tabnum 1 : Processing Ticket,  tabnum 2 : Solution

                  if ($tabnum == 2 or $tabnum == 1) {
                        // we must check if we can solve item even if PM case is still running (ex: PIR tasks for Change Management)
                        $pmCanSolve = PluginProcessmakerCase::canSolve( $params );
                     if (!$pmCanSolve) {
                        // don't display message if arbehaviours is install
                        if (!($plugin->isInstalled('arbehaviours') && $plugin->isActivated('arbehaviours'))) {
                           $messageOne = $LANG['processmaker']['item']['preventsolution'][1];
                           $messageTwo = $LANG['processmaker']['item']['preventsolution'][2];
                           // output explicit message to explain why it's not possible to add solution

                           $message = "<div style='margin-bottom: 20px;' class='box'>
                                    <div class='box-tleft'>
                                        <div class='box-tright'>
                                            <div class='box-tcenter'>
                                            </div>
                                        </div>
                                    </div>
                                    <div class='box-mleft'>
                                        <div class='box-mright'>
                                            <div class='box-mcenter'>
                                                <h3>
                                                    <span class='red'>".$messageOne."
                                                        <br>
                                                    </span>
                                                </h3>
                                                <h3>
                                                <span >".$messageTwo."
                                                    </span>
                                                </h3>
                                            </div>
                                         </div>
                                     </div>
                                     <div class='box-bleft'>
                                        <div class='box-bright'>
                                            <div class='box-bcenter'>
                                            </div>
                                        </div>
                                     </div>
                                  </div>  ";
                        }

                        $pmHideSolution = true;
                        $itemtype = strtolower($itemtype);
                        if ($tabnum == 1 && isset($_SESSION['glpiactiveprofile'][$itemtype.'_status'])) {
                           // don't display message if arbehaviours is install
                           if (!($plugin->isInstalled('arbehaviours') && $plugin->isActivated('arbehaviours'))) {
                              self::displayMessage($message, '', WARNING);

                              //save current  $_SESSION['glpiactiveprofile'][$itemtype.'_status'']
                              $_SESSION['glpiactiveprofile'][$itemtype.'_status_save'] = $_SESSION['glpiactiveprofile'][$itemtype.'_status'];
                              // for all $params['options']['itemtype']. status, disable solved ( life cycles )
                              foreach ($_SESSION['glpiactiveprofile'][$itemtype.'_status'] as $key => $value) {
                                 $_SESSION['glpiactiveprofile'][$itemtype.'_status'][$key][CommonITILObject::SOLVED] = 0;
                              }
                           }
                        } else {
                           // then output a new div and hide solution for content
                           echo $message;
                           echo "<div id='toHideSolution' style='display: none;'>";
                        }
                     }
                  }
               }
            }

      }
   }


   public static function post_show_tab_processmaker($params) {
      global $pmHideSolution;

      $itemtype = $params['item']->getType();
      switch ($itemtype) {

         case 'Ticket':
         case 'Problem':
         case 'Change':
            if ($params['options']['id']) {
               // then we are in an itil object
               if (isset($_SESSION['glpiactiveprofile']['interface']) && $_SESSION['glpiactiveprofile']['interface'] != "helpdesk") {
                  $tabnum = $params['options']['tabnum'];

                  if ($tabnum == 2 or $tabnum == 1) {
                     // then we are showing the Solution tab or Processing Ticket tab

                     if ($pmHideSolution) {
                        echo "</div>";

                     }
                     $itemtype = strtolower($itemtype);
                     // replace $_SESSION['glpiactiveprofile'][$itemtype.'_status'] with saved value
                     if ($tabnum == 1 && isset($_SESSION['glpiactiveprofile'][$itemtype.'_status_save'])) {
                        $_SESSION['glpiactiveprofile'][$itemtype.'_status'] = $_SESSION['glpiactiveprofile'][$itemtype.'_status_save'];
                     }

                  }
               }

            }
            break;

      }

   }


    ///**
    // * Summary of post_show_item_processmakerticket
    // * @param $parm
    // */
    //public static function post_show_item_processmakerticket($parm) {
    //    global $LANG, $pmHideSolution;
    //    if( ($plug = new Plugin)  && !$plug->isActivated('arbehaviours') ) {
    //        if ($parm->getID() && in_array($parm->getType(), array('Ticket'))) {
    //            // then we are in a ticket
    //            if (isset($_REQUEST['glpi_tab']) && $_SESSION['glpiactiveprofile']['interface'] != "helpdesk" ) {
    //                $data     = explode('$', $_REQUEST['glpi_tab']);
    //                $itemtype = $data[0];
    //                // Default set
    //                $tabnum   = 1;
    //                if (isset($data[1])) {
    //                    $tabnum = $data[1];
    //                }
    //                elseif ($itemtype == -1 )
    //                    $tabnum = -1 ;

    //                if( $tabnum == 2 || $tabnum == -1 ) {
    //                    // then we are showing the Solution tab
    //                    // if a case is running
    //                    // then we must prevent solution to be input
    //                    if( $pmHideSolution ) { //isset($pmVar['GLPI_ITEM_CAN_BE_SOLVED']) && $pmVar['GLPI_ITEM_CAN_BE_SOLVED'] != 1 ) { //if( $pmInfo !== null && ( $pmInfo->caseStatus != 'COMPLETED' && $pmInfo->caseStatus != 'CANCELLED' )) {

    //                        echo "</div>";
    //                        if( $tabnum == -1 )
    //                            echo "</div>";
    //                        echo "<div style='margin-bottom: 20px;' class='box'>
    //                                <div class='box-tleft'>
    //                                    <div class='box-tright'>
    //                                        <div class='box-tcenter'>
    //                                        </div>
    //                                    </div>
    //                                </div>
    //                                <div class='box-mleft'>
    //                                    <div class='box-mright'>
    //                                        <div class='box-mcenter'>
    //                                            <h3>
    //                                                <span class='red'>".$LANG['processmaker']['item']['preventsolution'][1]."
    //                                                    <br>
    //                                                </span>
    //                                            </h3>
    //                                            <h3>
    //                                            <span >".$LANG['processmaker']['item']['preventsolution'][2]."
    //                                                </span>
    //                                            </h3>
    //                                        </div>
    //                                     </div>
    //                                 </div>
    //                                 <div class='box-bleft'>
    //                                    <div class='box-bright'>
    //                                        <div class='box-bcenter'>
    //                                        </div>
    //                                    </div>
    //                                 </div>
    //                              </div>  ";
    //                    }
    //                }
    //            }
    //        }
    //    }
    //}

    ///**
    // * Summary of canedit_item_processmakertickettask
    // * @param $parm
    // */
    //public static function canedit_item_processmakertickettask($parm) {
    //    global $DB, $LANG, $_SESSION ;
    //    // must check if Task is bound to a PM task
    //    $query = "SELECT * FROM glpi_plugin_processmaker_tasks WHERE itemtype='".$parm->getType()."' and items_id=".$parm->getId().";" ;
    //    $res = $DB->query($query) ;
    //    if( $DB->numrows($res) > 0) {
    //        $parm->fields['plugin_canedit'] = false ; // to prevent task edition
    //        // replace ##ticket.url##_PluginProcessmakerCase$processmakercases by a setActiveTab to the Case panel
    //        $taskCat = new TaskCategory ;
    //        $taskCat->getFromDB( $parm->fields['taskcategories_id'] ) ;
    //        $taskComment = (isset($taskCat->fields['comment'])?$taskCat->fields['comment']:'') ;
    //        if( Session::haveTranslations('TaskCategory', 'comment') ) {
    //           $parm->fields['content'] = str_replace( '##processmaker.taskcomment##', DropdownTranslation::getTranslatedValue( $taskCat->getID(), 'TaskCategory', 'comment', $_SESSION['glpilanguage'], $taskComment ), $parm->fields['content'] ) ;
    //        } else {
    //           $parm->fields['content'] = str_replace( '##processmaker.taskcomment##', $taskComment, $parm->fields['content'] ) ;
    //        }
    //        $parm->fields['content'] = str_replace( '##ticket.url##_PluginProcessmakerCase$processmakercases', "<a href=\"javascript:tabpanel.setActiveTab('PluginProcessmakerCase\$processmakercases');\">".$LANG['processmaker']['item']['task']['manage_text']."</a>", $parm->fields['content'] ) ;
    //        if( isset( $parm->fields['tr_id'] ) ) {
    //            $trID = $parm->fields['tr_id'] ;
    //            $parm->fields['content'] .= "<script>var loc$trID = document.getElementById('$trID'); loc$trID.style.cursor = 'pointer'; if (loc$trID.addEventListener) { loc$trID.addEventListener('click', function(){tabpanel.setActiveTab('PluginProcessmakerCase\$processmakercases');}, false);} else {loc$trID.attachEvent('onclick', function(){tabpanel.setActiveTab('PluginProcessmakerCase\$processmakercases');});  } </script>";
    //        }
    //    }
    //}

    /**
     * Summary of getItemUsers
     * returns an array of glpi ids and pm ids for each user type assigned to given ticket
     * @param string  $itemtype
     * @param integer $itemId   is the ID of the titem
     * @param integer $userType is 1 for ticket requesters, 2 for ticket technicians, and if needed, 3 for watchers
     * @return array of users in the returned array
     */
   public static function getItemUsers( $itemtype, $itemId, $userType ) {
        global $DB;

      $users = array( );

      //$itemtable = getTableForItemType( $itemtype ) ;
      $item = new $itemtype();
      $item_users = $item->userlinkclass;
      $item_userstable = getTableForItemType( $item_users );
      $itemlink = getForeignKeyFieldForItemType( $itemtype );

        $query = "select glpi_plugin_processmaker_users.pm_users_id as pm_users_id, glpi_plugin_processmaker_users.id as id from $item_userstable
				left join glpi_plugin_processmaker_users on glpi_plugin_processmaker_users.id = $item_userstable.users_id
				where $item_userstable.$itemlink = $itemId and $item_userstable.type = $userType
                order by $item_userstable.id";
      foreach ($DB->request( $query ) as $dbuser) {
         $users[] = array( 'glpi_id' => $dbuser['id'], 'pm_id' => $dbuser['pm_users_id'] );
      }

        return $users;
   }

    /**
     * Summary of saveForm
     * This function posts dynaform variables to PM, using the CURL module.
     * @param mixed $request: is the $_REQUEST server array
     * //@param string $cookie: is the $_SERVER['HTTP_COOKIE'] string
     * @return mixed: returns false if request failed, otherwise, returns true
     */
   public function saveForm( $request ) {
      //, $cookie ) {

      if (!function_exists( 'HandleHeaderLine' )) {
         function HandleHeaderLine( $curl, $header_line ) {
              //global $cookies;
            $temp = explode( ": ", $header_line );
            if (is_array( $temp ) && $temp[0] == 'Set-Cookie') {
               $temp2 = explode( "; ", $temp[1]);
               //$cookies .= $temp2[0].'; ' ;
               curl_setopt($curl, CURLOPT_COOKIE, $temp2[0]."; " );
            }
            return strlen($header_line);
         }
      }
      $request = stripcslashes_deep( $request );

      $data = http_formdata_flat_hierarchy( $request );

      $ch = curl_init();

      //to be able to trace network traffic with a local proxy
      //curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, 1 ) ;
      //curl_setopt($ch, CURLOPT_PROXY, "localhost:8889");

      curl_setopt($ch, CURLOPT_HEADER, 1);
      //		curl_setopt($ch, CURLOPT_VERBOSE, 1);
      //		curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);

      curl_setopt($ch, CURLOPT_HEADERFUNCTION, "HandleHeaderLine");

      curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

      curl_setopt($ch, CURLOPT_URL, $this->serverURL."/cases/cases_Open?sid=".$_SESSION["pluginprocessmaker"]["session"]["id"]."&APP_UID=".$request['APP_UID']."&DEL_INDEX=".$request['DEL_INDEX']."&action=TO_DO" );
      $response = curl_exec ($ch);
        //Toolbox::logInFile( "pmtrace", "URL:\n".$this->serverURL."/cases/cases_Open?sid=".$_SESSION["pluginprocessmaker"]["session"]["id"]."\nResponse:\n".$response."\n\n\n" ) ;

      curl_setopt($ch, CURLOPT_POST, 1);
      curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

      curl_setopt($ch, CURLOPT_URL, $this->serverURL."/cases/cases_SaveData?UID=".$request['UID']."&APP_UID=".$request['APP_UID'] );

      $response = curl_exec ($ch);

      curl_close ($ch);
        //Toolbox::logInFile( "pmtrace", "URL:\n".$this->serverURL."/cases/cases_SaveData?UID=".$request['UID']."&APP_UID=".$request['APP_UID']."\nData:\n".print_r($data, true )."\nResponse:\n".$response."\n\n\n" ) ;

      return ($response ? true : false);

      //$n = preg_match("/HTTP\/1.1 302 /", $response, $matches);

      //return ($n < 1 ? false : true) ;
   }

    /**
     * Summary of plugin_item_get_datas_processmaker
     * @param mixed $item
     */
   public static function plugin_item_get_datas_processmaker($item) {
      global $_SESSION;
      if (isset( $item->datas ) && isset( $item->datas['tasks'] )) {
         foreach ($item->datas['tasks'] as &$task) { // we must check if task category is PM task category or not, if yes then we add task category comment to datas
            $task['##task.description##'] = str_replace( '##processmaker.taskcomment##', $task['##task.categorycomment##'], $task['##task.description##'] );
         }
      }

   }


      /**
       * Summary of plugin_item_get_pdfdatas_processmaker
       * @param mixed $item
       */
   public static function plugin_item_get_pdfdatas_processmaker($item) {
      if (isset( $item->datas )) {
         $config = PluginProcessmakerConfig::getInstance();
         $taskCat = new TaskCategory;

         // save current translations
         if (isset( $_SESSION['glpi_dropdowntranslations'] )) {
            $trans = $_SESSION['glpi_dropdowntranslations'];
         }
         // load available translations for this user
         $_SESSION['glpi_dropdowntranslations'] = DropdownTranslation::getAvailableTranslations($_SESSION['glpilanguage']);

         $taskCat->getFromDB( $item->datas['taskcategories_id'] );
         $ancestors = getAncestorsOf( 'glpi_taskcategories', $item->datas['taskcategories_id']);
         if (in_array( $config->fields['taskcategories_id'], $ancestors)) {
            $loc_completename = DropdownTranslation::getTranslatedValue( $taskCat->getID(), 'TaskCategory', 'completename', $_SESSION['glpilanguage'], $taskCat->fields['completename'] );
            $loc_comment = DropdownTranslation::getTranslatedValue( $taskCat->getID(), 'TaskCategory', 'comment', $_SESSION['glpilanguage'], $taskCat->fields['comment'] );
            $item->datas['content'] = $loc_completename."\n\n".str_replace( "##processmaker.taskcomment##\n##ticket.url##_PluginProcessmakerCase\$processmakercases", $loc_comment, $item->datas['content']);
         }
         // restore default translations
         if (isset( $trans )) {
            $_SESSION['glpi_dropdowntranslations'] = $trans;
         } else {
            unset( $_SESSION['glpi_dropdowntranslations']  );
         }
      }

   }


      /**
     * Summary of getProcessesWithCategoryAndProfile
     * @param mixed $category
     * @param mixed $type
     * @param mixed $profile
     * @param mixed $entity
     */
   public static function getProcessesWithCategoryAndProfile( $category, $type, $profile, $entity ) {
      global $DB;

      $processList = array( );
      $entityAncestors = implode( ", ", getAncestorsOf( getTableForItemType( 'Entity' ), $entity ) );
      if (strlen( $entityAncestors ) > 0) {
         $entityAncestors = " OR (entities_id IN ($entityAncestors) AND is_recursive = 1) ";
      }

      $query ="SELECT DISTINCT glpi_plugin_processmaker_processes.id, glpi_plugin_processmaker_processes.name FROM glpi_plugin_processmaker_processes
            INNER JOIN glpi_plugin_processmaker_processes_profiles ON glpi_plugin_processmaker_processes_profiles.processes_id=glpi_plugin_processmaker_processes.id
            WHERE is_active = 1 AND itilcategories_id = $category AND `type` = $type AND profiles_id = $profile  AND (entities_id = $entity $entityAncestors)";

      foreach ($DB->request( $query ) as $row) {
         $processList[] = $row;
      }

      return $processList;

   }

   public function startNewCase( $processId, $itemType, $itemId, $userId=null ) {
      global $DB, $CFG_GLPI;

      $requesters = PluginProcessmakerProcessmaker::getItemUsers( $itemType, $itemId, CommonITILActor::REQUESTER); // 1 for requesters
      if (!key_exists( 0, $requesters )) {
         $requesters[0]['glpi_id'] = 0;
         $requesters[0]['pm_id'] = 0;
      }

      $impersonateCase = false;
      if (!$userId) {
         // then we are going to take the item creator to set it as case creator and
         $impersonateCase = true;

      }

      // get item info to retreive title, description and duedate
      $locItem = new $itemType; // $_POST['itemtype'] ; //Ticket();
      $locItem->getFromDB( $itemId ); // $_POST['id'] ) ;

      if ($locItem->countUsers(CommonITILActor::ASSIGN) == 0
         || !$locItem->isUser(CommonITILActor::ASSIGN, $userId) ) {
         $locItem->update( array( 'id' => $itemId, '_itil_assign' => array( '_type' => 'user', 'users_id' => $userId )  ) );
      }

      if (!isset($locItem->fields['due_date']) || $locItem->fields['due_date'] == null) {
         $locItem->fields['due_date'] = "";
      }

      $resultCase = $this->newCase( $processId,
                                     array('GLPI_ITEM_CAN_BE_SOLVED'        => 0,
                                           'GLPI_TICKET_ID'                 => $itemId,
                                           'GLPI_ITEM_ID'                   => $itemId,
                                           'GLPI_ITEM_TYPE'                 => $itemType,
                                           'GLPI_TICKET_REQUESTER_GLPI_ID'  => $requesters[0]['glpi_id'],
                                           'GLPI_ITEM_REQUESTER_GLPI_ID'    => $requesters[0]['glpi_id'],
                                           'GLPI_TICKET_REQUESTER_PM_ID'    => $requesters[0]['pm_id'],
                                           'GLPI_ITEM_REQUESTER_PM_ID'      => $requesters[0]['pm_id'],
                                           'GLPI_TICKET_TITLE'              => $locItem->fields['name'],
                                           'GLPI_ITEM_TITLE'                => $locItem->fields['name'],
                                           'GLPI_TICKET_DESCRIPTION'        => $locItem->fields['content'],
                                           'GLPI_ITEM_DESCRIPTION'          => $locItem->fields['content'],
                                           'GLPI_TICKET_DUE_DATE'           => $locItem->fields['due_date'],
                                           'GLPI_ITEM_DUE_DATE'             => $locItem->fields['due_date'],
                                           'GLPI_ITEM_ITIL_CATEGORY_ID'     => $locItem->fields['itilcategories_id'],
                                           'GLPI_TICKET_URGENCY'            => $locItem->fields['urgency'],
                                           'GLPI_ITEM_URGENCY'              => $locItem->fields['urgency'],
                                           'GLPI_ITEM_IMPACT'               => $locItem->fields['impact'],
                                           'GLPI_ITEM_PRIORITY'             => $locItem->fields['priority'],
                                           'GLPI_TICKET_GLOBAL_VALIDATION'  => $locItem->fields['global_validation'] ,
                                           'GLPI_TICKET_TECHNICIAN_GLPI_ID' => $userId,
                                           'GLPI_ITEM_TECHNICIAN_GLPI_ID'   => $userId,
                                           'GLPI_TICKET_TECHNICIAN_PM_ID'   => PluginProcessmakerUser::getPMUserId( $userId ),
                                           'GLPI_ITEM_TECHNICIAN_PM_ID'     => PluginProcessmakerUser::getPMUserId( $userId ),
                                           'GLPI_URL'                       => $CFG_GLPI['url_base'].$CFG_GLPI['root_doc']
                                           ) );

      if ($resultCase->status_code === 0) {
          $caseInfo = $this->getCaseInfo( $resultCase->caseId );

          //$query = "UPDATE APPLICATION SET APP_STATUS='TO_DO' WHERE APP_UID='".$resultCase->caseId."' AND APP_STATUS='DRAFT'" ;
          //$res = $DB->query($query) ;
          // save info to DB
          $locCase = new PluginProcessmakerCase;
          $locCase->add( array( 'id' => $resultCase->caseId,
                                'items_id' => $itemId,
                                'itemtype' => $itemType,
                                'case_num' => $resultCase->caseNumber,
                                'case_status' => $caseInfo->caseStatus,
                                'processes_id' => $processId //$caseInfo->processId
                        ), true );
          //$query = "INSERT INTO glpi_plugin_processmaker_cases (items_id, itemtype, id, case_num, case_status, processes_id) VALUES ($itemId, '$itemType', '".$resultCase->caseId."', ".$resultCase->caseNumber.", '".$caseInfo->caseStatus."', '".$caseInfo->processId."');" ;
          //$res = $DB->query($query) ;

         $this->add1stTask($itemType, $itemId, $caseInfo, array( 'userId' => $userId ) );
      }

      return $resultCase;
   }


   /**
    * Summary of derivateCase
    * in $request must be present
    * 'UID', 'APP_UID' and DEL_INDEX'
    *
    * @param mixed $myCase
    * @param mixed $request
    * @param mixed $users_id
   */
   public function derivateCase( $myCase, $request, $users_id=null ) {
      //$cookies,
      global $PM_DB;

      // save the case variables
      $resultSave = $this->saveForm( $request );

      // now derivate the case !!!
      $pmRouteCaseResponse = $this->routeCase( $myCase->getID(), $request['DEL_INDEX']);

      $casevariables = ["GLPI_ITEM_TASK_CONTENT",
                        "GLPI_ITEM_APPEND_TO_TASK",
                        "GLPI_NEXT_GROUP_TO_BE_ASSIGNED",
                        "GLPI_ITEM_TITLE",
                        "GLPI_TICKET_FOLLOWUP_CONTENT",
                        "GLPI_TICKET_FOLLOWUP_IS_PRIVATE",
                        "GLPI_TICKET_FOLLOWUP_REQUESTTYPES_ID",
                        "GLPI_ITEM_TASK_ENDDATE",
                        "GLPI_ITEM_TASK_STARTDATE",
                        "GLPI_ITEM_SET_STATUS",
                        "GLPI_ITEM_SET_SOLUTION_TEMPLATE_ID",
                        "GLPI_ITEM_SET_SOLUTION_TYPE_ID",
                        "GLPI_ITEM_APPEND_TO_SOLUTION_DESCRIPTION"
                       ];

      // now tries to get some variables to setup content for new task and to append text to solved task
      $casevariablevalues = $this->getVariables($myCase->getID(), $casevariables);

      $itemSetStatus = '';
      if (array_key_exists( 'GLPI_ITEM_SET_STATUS', $casevariablevalues )) {
         $itemSetStatus = $casevariablevalues[ 'GLPI_ITEM_SET_STATUS' ];
      }

      $txtItemTitle  = '';
      if (array_key_exists( 'GLPI_ITEM_TITLE', $casevariablevalues )) {
         $txtItemTitle = $casevariablevalues[ 'GLPI_ITEM_TITLE' ];
      }

      $txtToAppendToTask  = '';
      if (array_key_exists( 'GLPI_ITEM_APPEND_TO_TASK', $casevariablevalues )) {
         $txtToAppendToTask = $casevariablevalues[ 'GLPI_ITEM_APPEND_TO_TASK' ];
      }

      $txtTaskContent = '';
      if (array_key_exists( 'GLPI_ITEM_TASK_CONTENT', $casevariablevalues )) {
         $txtTaskContent = $casevariablevalues[ 'GLPI_ITEM_TASK_CONTENT' ];
      }

      $groupId = 0;
      if (array_key_exists( 'GLPI_NEXT_GROUP_TO_BE_ASSIGNED', $casevariablevalues )) {
         $groupId = $casevariablevalues[ 'GLPI_NEXT_GROUP_TO_BE_ASSIGNED' ];
      }

      $taskStartDate = '';
      $taskEndDate = '';
      if (array_key_exists( 'GLPI_ITEM_TASK_ENDDATE', $casevariablevalues )) {
         $taskEndDate = $casevariablevalues[ 'GLPI_ITEM_TASK_ENDDATE' ];
      }
      if (array_key_exists( 'GLPI_ITEM_TASK_STARTDATE', $casevariablevalues )) {
         $taskStartDate = $casevariablevalues[ 'GLPI_ITEM_TASK_STARTDATE' ];
         if ($taskEndDate == '') {
            // at least
            $taskEndDate = $taskStartDate;
         }
      }

      $createFollowup = false; // by default
      if (array_key_exists( 'GLPI_TICKET_FOLLOWUP_CONTENT', $casevariablevalues ) && $casevariablevalues[ 'GLPI_TICKET_FOLLOWUP_CONTENT' ] != '') {
         //&& array_key_exists( 'GLPI_TICKET_FOLLOWUP_IS_PRIVATE', $infoForTasks )
         //&& array_key_exists( 'GLPI_TICKET_FOLLOWUP_REQUESTTYPES_ID', $infoForTasks )
         $createFollowup = true;
      }

      // reset those variables
      $resetcasevariables = [];
      foreach($casevariables as $val) {
         $resetcasevariables[$val] = '';
      }
      $resultSave = $this->sendVariables($myCase->getID(), $resetcasevariables);

      // print_r( $pmRouteCaseResponse ) ;
      // die() ;

      // now manage tasks associated with item
      $itemType = $myCase->getField('itemtype');
      $itemId = $myCase->getField('items_id');

      // switch own task to 'done' and create a new one
      $this->solveTask( $myCase->getID(), $request['DEL_INDEX'], array( 'txtToAppend' => $txtToAppendToTask, 'users_id_tech' => $users_id ) );

      // create a followup if requested
      if ($createFollowup && $itemType == 'Ticket') {
         $this->addTicketFollowup( $itemId, $casevariablevalues );
      }
      $caseInfo = $this->getCaseInfo(  $myCase->getID(), $request['DEL_INDEX']);
      if (property_exists( $pmRouteCaseResponse, 'routing' )) {
         foreach ($pmRouteCaseResponse->routing as $route) {
            $this->addTask( $itemType,
                                      $itemId,
                                      $caseInfo,
                                      $route->delIndex,
                                      PluginProcessmakerUser::getGLPIUserId( $route->userId ),
                                      $groupId,
                                      $route->taskId,
                                      array( 'txtTaskContent' => $txtTaskContent,
                                             'start_date'     => $taskStartDate,
                                             'end_date' => $taskEndDate)
                                    );

            // if end date was specified, then must change due date of the PM task
            if ($taskEndDate != '') {
               $PM_DB->query( "UPDATE APP_DELEGATION SET DEL_TASK_DUE_DATE='$taskEndDate' WHERE APP_UID='".$caseInfo->caseId."' AND DEL_INDEX=".$route->delIndex);
            }
         }
      }

      if ($txtItemTitle != '') {
         // we are going to change the title of current GLPI Item
         $this->setItemTitle($itemType, $itemId, $txtItemTitle);
      }

      if ($itemSetStatus != '') {
         $this->setItemStatus($itemType, $itemId, $itemSetStatus );
      }

      if (array_key_exists( 'GLPI_ITEM_SET_SOLUTION_TEMPLATE_ID', $casevariablevalues )
          || array_key_exists( 'GLPI_ITEM_SET_SOLUTION_TYPE_ID', $casevariablevalues )
          || array_key_exists( 'GLPI_ITEM_APPEND_TO_SOLUTION_DESCRIPTION', $casevariablevalues )) {
         // case requests to add a solution to ticket
         $this->setItemSolution($itemType, $itemId, $casevariablevalues);
      }

      // evolution of case status: DRAFT, TO_DO, COMPLETED, CANCELLED
      $myCase->update( array( 'id' => $myCase->getID(), 'case_status' => $caseInfo->caseStatus ) );
   }


    /**
     * Summary of getPMGroups
     * @return array
     */
   public static function getPMGroups( ) {
      global $PM_DB;
      $pmGroupList = array();
      foreach ($PM_DB->request("SELECT * FROM CONTENT WHERE CONTENT.CON_CATEGORY='GRP_TITLE' AND CONTENT.CON_LANG='en'") as $dbgroup) {
         $pmGroupList[$dbgroup['CON_VALUE']] = $dbgroup;
      }
      return $pmGroupList;
   }


    /**
     * Summary of displayMessage
     * Show a html message bottom-right of screen
     * @param string $html_message message to be shown
     * @param string $title        if '' then title bar is not shown (default '')
     * @param string $msgtype      the type of the message (ERROR | WARNING | INFO)
     * @return void
     **/
   static private function displayMessage($html_message, $title='',$msgtype='info_msg') {

      //set title and css class
      switch ($msgtype) {
         case ERROR:
            $title = __('Error');
            $class = 'err_msg';
            break;
         case WARNING:
            $title = __('Warning');
            $class = 'warn_msg';
            break;
         case INFO:
            $title = __('Information');
            $class = 'info_msg';
            break;
      }

      echo "<div id=\"message_after_redirect_$msgtype\" title=\"$title\">";
      echo $html_message;
      echo "</div>";

      $scriptblock = "
               $(document).ready(function() {
                  var _of = window;
                  var _at = 'right-20 bottom-20';
                  //calculate relative dialog position
                  $('.message_after_redirect').each(function() {
                     var _this = $(this);
                     if (_this.attr('aria-describedby') != 'message_after_redirect_$msgtype') {
                        _of = _this;
                        _at = 'right top-' + (10 + _this.outerHeight());
                     }
                  });

                  $('#message_after_redirect_$msgtype').dialog({
                     dialogClass: 'message_after_redirect $class',
                     minHeight: 40,
                     minWidth: 200,
                     position: {
                        my: 'right bottom',
                        at: _at,
                        of: _of,
                        collision: 'none'
                     },
                     autoOpen: false,
                     show: {
                       effect: 'slide',
                       direction: 'down',
                       'duration': 800
                     }
                  })
                  .dialog('open');";

      //do not autoclose errors
      if ($msgtype != ERROR) {
         $scriptblock .= "

                  // close dialog on outside click
                  $(document.body).on('click', function(e){
                     if ($('#message_after_redirect_$msgtype').dialog('isOpen')
                         && !$(e.target).is('.ui-dialog, a')
                         && !$(e.target).closest('.ui-dialog').length) {
                        $('#message_after_redirect_$msgtype').dialog('close');
                        // redo focus on initial element
                        e.target.focus();
                     }
                  });";
      }

      $scriptblock .= "

               });
            ";

      echo Html::scriptBlock($scriptblock);
   }

   //static protected $saved_ob_level;

   //static function pre_item_form_processmakerticket($item) {
   //   self::$saved_ob_level = ob_get_level();
   //   ob_start();

   //}

   //static function post_item_form_processmakerticket($item) {
   //   $buffer = ob_get_clean();
   //   // 9.1 only: hack to fix an issue with the initEditorSystem which calls scriptStart without calling scriptEnd
   //   if (ob_get_level() > self::$saved_ob_level) {
   //      $buffer = ob_get_clean().$buffer;
   //   }
   //   echo $buffer;
   //}

}