luos/workflow/engine/classes/class.pmFunctions.php

<?php
/**
 * class.pmFunctions.php
 * @package workflow.engine.ProcessMaker
 *
 * ProcessMaker Open Source Edition
 * Copyright (C) 2004 - 2011 Colosa Inc.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * For more information, contact Colosa Inc, 2566 Le Jeune Rd.,
 * Coral Gables, FL, 33134, USA, or email info@colosa.com.
 *
 */
////////////////////////////////////////////////////
// PM Functions
//
// Copyright (C) 2007 COLOSA
//
// License: LGPL, see LICENSE
////////////////////////////////////////////////////

/**
 * ProcessMaker has made a number of its PHP functions available be used in triggers and conditions.
 * Most of these functions are wrappers for internal functions used in Gulliver, which is the development framework
 * used by ProcessMaker.
 * class pmFunctions
 * @name ProcessMaker Functions
 * icon /images/pm.gif
 * className class.pmFunctions.php
 */


/**
 * method
 *
 * Returns the current date formated in the format "yyyy-mm-dd", with leading zeros in the
 * month and day if less than 10. This function is equivalent to PHP's date("Y-m-d").
 *
 * @name getCurrentDate
 * label Get Current Date
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#getCurrentDate.28.29
 *
 * @return date | $date | Current Date (Y-m-d) | It returns the current date as a string value.
 *
 */
function getCurrentDate() {
  return G::CurDate('Y-m-d');
}
/**
 * method
 *
 * Returns the current time in the format "hh:mm:ss" with leading zeros when the hours,
 * minutes or seconds are less than 10.
 *
 * @name getCurrentTime
 * label Get Current Time
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#getCurrentTime.28.29
 *
 * @return time | $time | Current Time (H:i:s)| The function returns the current time as a string.
 *
 */
function getCurrentTime() {
  return G::CurDate('H:i:s');
}
/**
 * method
 *
 * Retrieves information about a user with a given ID.
 *
 * @name userInfo
 * label User Info
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#userInfo.28.29
 *
 * @param string(32) | $user_id | User ID | The user unique ID
 * @return array | $userInfo | User Info | An associative array with Information
 *
 */
function userInfo($user_uid) {
  try {
    require_once 'classes/model/Users.php';
    $oUser = new Users();
    return $oUser->getAllInformation($user_uid);
  }
  catch (Exception $oException) {
    throw $oException;
  }
}
/**
 * method
 *
 * Returns a string converted into all UPPERCASE letters.
 *
 * @name upperCase
 * label Upper Case
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#upperCase.28.29
 *
 * @param string(32) | $sText | Text To Convert | A string to convert to UPPERCASE letters.
 * @return string | $TextC | Text Converted | Returns a string with the text converted into upper case letters.
 *
 */
function upperCase($sText) {
  return G::toUpper($sText);
}
/**
 * method
 *
 * Returns a string with all the letters converted into lower case letters.
 *
 * @name lowerCase
 * label Lower Case
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#lowerCase.28.29
 *
 * @param string(32) | $sText | Text To Convert | A string to convert to lower case letters.
 * @return string | $TextC | Text Converted | Returns a string with the text converted into lower case letters.
 *
 */
function lowerCase($sText) {
  return G::toLower($sText);
}
/**
 * method
 *
 * Converts the first letter in each word into an uppercase letter.
 * Subsequent letters in each word are changed into lowercase letters.
 *
 * @name capitalize
 * label Capitalize
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#capitalize.28.29
 *
 * @param string(32) | $sText | Text To Convert | The string to capitalize.
 * @return string | $TextC | Text Converted | It returns the introduced text with the first letter capitalized in each word and the subsequent letters into lowercase letters
 *
 */
function capitalize($sText) {
  return G::capitalizeWords($sText);
}
/**
 * method
 *
 * Returns a string formatted according to the given date format and given language
 *
 * @name formatDate
 * label Format Date
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#formatDate.28.29
 *
 * @param string(32) | $date | Date | The input date to be reformatted. The input date must be a string in the format 'yyyy-mm-dd'.
 * @param string(32) | $format="" | format | The format of the date which will be returned. It can have the following definitions:
 * @param string(32) | $lang="en"| Language | The language in which to reformat the date. It can be 'en' (English), 'es' (Spanish) or 'fa' (Persian).
 * @return string | $formatDate | Date whit format | It returns the passed date according to the given date format.
 *
 */
function formatDate($date, $format='', $lang='en') {
  if( !isset($date) or $date == '') {
    throw new Exception('function:formatDate::Bad param');
  }
  try {
    return G::getformatedDate($date, $format, $lang);
  } catch (Exception $oException) {
    throw $oException;
  }
}
/**
 * method
 *
 * Returns a specified date written out in a given language, with full month names.
 *
 * @name literalDate
 * label Literal Date
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#literalDate.28.29
 *
 * @param string(32) | $date | date | The input date in standard format (yyyy-mm-dd) that is a string.
 * @param string(32) | $lang="en" | Language | The language to display, which can be 'en' (English) or 'es' (Spanish). If not included, then it will be English by default.
 * @return string | $literaDate | Literal date | It returns the literal date as a string value.
 *
 */
function literalDate($date, $lang = 'en') {
  if( !isset($date) or $date == '' ) {
    throw new Exception('function:formatDate::Bad param');
  }
  try {
    switch($lang) {
      case 'en': $ret = G::getformatedDate($date, 'M d,yyyy', $lang);
        break;
      case 'es': $ret = G::getformatedDate($date, 'd de M de yyyy', $lang);
        break;
    }
    return $ret;
  } catch (Exception $oException) {
    throw $oException;
  }
}
/**
 * method
 *
 * Pauses a specified case.
 *
 * @name pauseCase
 * label Pause Case
 * @link  http://wiki.processmaker.com/index.php/ProcessMaker_Functions#pauseCase.28.29
 *
 * @param string(32) | $sApplicationUID= "" | ID of the case | The unique ID of the case. The UID of the current case can be found in the system variable @@APPLICATION.
 * @param string(32) | $iDelegation = 0| Delegation index of the case | The delegation index of the current task in the case.
 * @param string(32) | $sUserUID = ""| ID user | The unique ID of the user who will pause the case.
 * @param string(32) | $sUnpauseDate = null  | Date | Optional parameter. The date in the format 'yyyy-mm-dd' indicating when to unpause the case.
 * @return None  | $none | None | None
 *
 */
function pauseCase($sApplicationUID = '', $iDelegation = 0, $sUserUID = '', $sUnpauseDate = null) {//var_dump($sApplicationUID, $iDelegation, $sUserUID, $sUnpauseDate);die(':|');
  try {
    if ($sApplicationUID == '') {
      throw new Exception('The application UID cannot be empty!');
    }
    if ($iDelegation == 0) {
      throw new Exception('The delegation index cannot be 0!');
    }
    if ($sUserUID == '') {
      throw new Exception('The user UID cannot be empty!');
    }
    G::LoadClass('case');
    $oCase = new Cases();
    $oCase->pauseCase($sApplicationUID, $iDelegation, $sUserUID, $sUnpauseDate);
  }
  catch (Exception $oException) {
    throw $oException;
  }
}
/**
 * method
 *
 * Executes a SQL statement in a database connection or in one of ProcessMaker's
 * internal databases.
 *
 * @name executeQuery
 * label execute Query
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#executeQuery.28.29
 *
 * @param string(32) | $SqlStatement | Sql query | The SQL statement to be executed. Do NOT include the database name in the SQL statement.
 * @param string(32) | $DBConnectionUID="workflow"| UID database | The UID of the database connection where the SQL statement will be executed.
 * @return array or string | $Resultquery | Result | Result of the query | If executing a SELECT statement, it returns an array of associative arrays
 *
 */
function executeQuery($SqlStatement, $DBConnectionUID = 'workflow') {
  try {
    $statement = trim($SqlStatement);
    $statement = str_replace('(', '', $statement);
    $con = Propel::getConnection($DBConnectionUID);
    $con->begin();

    $result = false;

    switch(true) {
      case preg_match("/^SELECT\s/i", $statement):
      case preg_match("/^EXECUTE\s/i", $statement):
        $rs = $con->executeQuery($SqlStatement);
        $con->commit();

        $result = Array();
        $i=1;
        while ($rs->next()) {
          $result[$i++] = $rs->getRow();
        }
        break;
      case preg_match("/^INSERT\s/i", $statement):
        $rs = $con->executeUpdate($SqlStatement);
        $con->commit();
        //$result = $lastId->getId();
        $result = 1;
        break;
      case preg_match("/^UPDATE\s/i", $statement):
        $rs = $con->executeUpdate($SqlStatement);
        $con->commit();
        $result =  $con->getUpdateCount();
        break;
      case preg_match("/^DELETE\s/i", $statement):
        $rs = $con->executeUpdate($SqlStatement);
        $con->commit();
        $result =  $con->getUpdateCount();
        break;
    }

    return $result;
  } catch (SQLException $sqle) {
    $con->rollback();
    throw $sqle;
  }
}
/**
 * method
 *
 * Sorts a grid according to a specified field in ascending or descending order.
 *
 * @name orderGrid
 * label order Grid
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#orderGrid.28.29
 *
 * @param array | $dataM | User ID |  A grid, which is a numbered array containing associative arrays with field names and their values, it has to be set like this "@=".
 * @param string(32) | $field | Name of field | The name of the field by which the grid will be sorted.
 * @param string(32) | $ord = "ASC"| Optional parameter | Optional parameter. The order which can either be 'ASC' (ascending) or 'DESC' (descending). If not included, 'ASC' will be used by default.
 * @return array | $dataM | Grid Sorted | Grid sorted
 *
 */
function orderGrid($dataM, $field, $ord = 'ASC') {
  if(!is_array($dataM) or !isset($field) or $field=='') {
    throw new Exception('function:orderGrid Error!, bad parameters found!');
  }
  for($i=1; $i <= count($dataM)-1; $i++) {
    for($j=$i+1; $j <= count($dataM); $j++) {
      if(strtoupper($ord) == 'ASC') {
        if(strtolower($dataM[$j][$field]) < strtolower($dataM[$i][$field])) {
          $swap  = $dataM[$i];
          $dataM[$i] = $dataM[$j];
          $dataM[$j] = $swap;
        }
      } else {
        if($dataM[$j][$field] > $dataM[$i][$field]) {
          $swap  = $dataM[$i];
          $dataM[$i] = $dataM[$j];
          $dataM[$j] = $swap;
        }
      }
    }
  }
  return $dataM;
}
/**
 * method
 *
 * Executes operations among the grid fields, such as addition, substraction, etc
 *
 * @name evaluateFunction
 * label evaluate Function
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#evaluateFunction.28.29
 *
 * @param array | $aGrid | Grid | The input grid.
 * @param string(32) | $sExpresion | Expression for the operation | The input expression for the operation among grid fields. The expression must always be within double quotes, otherwise a fatal error will occur. 
 * @return array | $aGrid | Grid | Grid with executed operation
 *
 */
function evaluateFunction($aGrid, $sExpresion) {
  $sExpresion = str_replace('Array','$this->aFields', $sExpresion);
  $sExpresion .= ';';
  G::LoadClass('pmScript');
  $pmScript = new PMScript();
  $pmScript->setScript($sExpresion);

  for($i=1; $i<=count($aGrid); $i++) {
    $aFields = $aGrid[$i];

    $pmScript->setFields($aFields);

    $pmScript->execute();

    $aGrid[$i] = $pmScript->aFields;
  }
  return $aGrid;
}

/** Web Services Functions **/
/**
 * method
 *
 * Logs in a user to initiate a web services session in a ProcessMaker server.
 *
 * @name WSLogin
 * label WS Login
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSLogin.28.29
 *
 * @param string(32) | $user | Username of the user | The username of the user who will login to ProcessMaker. All subsequent actions will be limited to the permissions of that user.
 * @param string(32) | $pass | Password encrypted | The user's password encrypted as an MD5 hash with 'md5:' prepended.
 * @param string(32) | $endpoint="" | URI of the WSDL | The URI (address) of the WSDL definition of the ProcessMaker web services.
 * @return string | $unique ID | Unique Id |The unique ID for the initiated session.
 *
 */
function WSLogin($user, $pass, $endpoint='') {
  $client = wSOpen(true);
  $params = array('userid'=>$user, 'password'=>$pass);
  $result = $client->__SoapCall('login', array($params));

  if($result->status_code == 0) {
    if($endpoint != '') {
      $_SESSION['WS_END_POINT'] = $endpoint;
    }
    return $_SESSION['WS_SESSION_ID'] = $result->message;
  } else {
    unset($_SESSION['WS_SESSION_ID']);
    $wp = (trim($pass) != "")?'YES':'NO';
    throw new Exception("WSAccess denied! for user $user with password $wp");
  }
}
/**
 * method
 *
 * Opens a connection for web services and returns a SOAP client object which is
 * used by all subsequent other WS function calls
 *
 * @name WSOpen
 * label WS Open
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSOpen.28.29
 *
 * @param boolean | $force=false | Optional Parameter | Optional parameter. Set to true to force a new connection to be created even if a valid connection already exists.
 * @return Object Client | $client | SoapClient object | A SoapClient object. If unable to establish a connection, returns NULL.
 *
 */
function WSOpen($force=false) {
  if(isset($_SESSION['WS_SESSION_ID']) || $force) {
    if( !isset ($_SESSION['WS_END_POINT']) ) {
      $defaultEndpoint = 'http://'.$_SERVER['SERVER_NAME'].':'.$_SERVER['SERVER_PORT'].'/sys'.SYS_SYS.'/en/green/services/wsdl';
    }
    $endpoint = isset( $_SESSION['WS_END_POINT'] ) ? $_SESSION['WS_END_POINT'] : $defaultEndpoint;
    $client = new SoapClient( $endpoint );
    return $client;
  } else {
    throw new Exception('WS session is not open');
  }
}
/**
 * method
 *
 * Returns all the tasks which has open delegations for the indicated case.
 *
 * @name WSTaskCase
 * label WS Task Case
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSTaskCase.28.29
 *
 * @param string(32) | $caseId | Case ID | The unique ID for the case. Case UIDs can be found with WSCaseList() and are stored in the field wf_<WORKSPACE>.APPLICATION.APP_UID.
 * @return array | $rows | Array of tasks open | An array of tasks in the indicated case which have open delegations.
 *
 */
function WSTaskCase($caseId) {
  $client = WSOpen();

  $sessionId = $_SESSION['WS_SESSION_ID'];

  $params = array('sessionId'=>$sessionId, 'caseId'=>$caseId);
  $result = $client->__soapCall('taskCase', array($params));

  $i = 1;
  if(isset ($result->taskCases)) {
    foreach ( $result->taskCases as $key=> $item) {
      if ( isset ($item->item) ) {
        foreach ( $item->item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      } else {
        foreach ( $item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      }

      $rows[$i++] = array ( 'guid' => $guid, 'name' => $name );
    }
  }
  return $rows;
}
/**
 * method
 *
 * Returns a list of tasks in which the logged-in user can initiate cases or is
 * assigned to these cases.
 *
 * @name WSTaskList
 * label WS Task List
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSTaskList.28.29
 *
 * @return array | $rows |List of tasks | This function returns a list of tasks
 *
 */
function WSTaskList() {
  $client = WSOpen();

  $sessionId = $_SESSION['WS_SESSION_ID'];
  $params = array('sessionId'=>$sessionId );
  $result = $client->__SoapCall('TaskList', array($params));

  $i = 1;
  if(isset ($result->tasks)) {
    foreach ( $result->tasks as $key=> $item) {
      if ( isset ($item->item) ) {
        foreach ( $item->item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      } else {
        foreach ( $item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      }

      $rows[$i++] = array ( 'guid' => $guid, 'name' => $name );
    }
  }
  return $rows;
}
/**
 * method
 *
 * Returns a list of users whose status is "ACTIVE" in the current workspace.
 *
 * @name WSUserList
 * label WS User List
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSUserList.28.29
 *
 * @return array | $rows | List | List of Active users in the workspace
 *
 */
function WSUserList() {
  $client = WSOpen();

  $sessionId = $_SESSION['WS_SESSION_ID'];
  $params = array('sessionId'=>$sessionId );
  $result = $client->__SoapCall('UserList', array($params));

  $i = 1;
  if(isset ($result->users)) {
    foreach ( $result->users as $key=> $item) {
      if ( isset ($item->item) ) {
        foreach ( $item->item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      } else {
        foreach ( $item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      }

      $rows[$i++] = array ( 'guid' => $guid, 'name' => $name );
    }
  }
  return $rows;
}
/**
 * method
 *
 * Returns a list of active groups in a workspace.
 *
 * @name WSGroupList
 * label WS Group List
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSGroupList.28.29
 *
 * @return array | $rows | List | List of active groups in the workspace
 *
 */
function WSGroupList() {
  $client = WSOpen();

  $sessionId = $_SESSION['WS_SESSION_ID'];
  $params = array('sessionId'=>$sessionId );
  $result = $client->__SoapCall('GroupList', array($params));

  $i = 1;
  if(isset ($result->groups)) {
    foreach ( $result->groups as $key=> $item) {
      if ( isset ($item->item) ) {
        foreach ( $item->item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      } else {
        foreach ( $item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      }

      $rows[$i++] = array ( 'guid' => $guid, 'name' => $name );
    }
  }
  return $rows;
}

/**
 * method
 *
 * Returns a list of roles in the current workspace.
 *
 * @name WSRoleList
 * label WS Role List
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSRoleList.28.29
 *
 * @return array | $rows | List | List of roles in the workspace
 *
 */
function WSRoleList() {
  $client = WSOpen();

  $sessionId = $_SESSION['WS_SESSION_ID'];
  $params = array('sessionId'=>$sessionId );
  $result = $client->__SoapCall('RoleList', array($params));
  $i = 1;
  if(isset ($result->roles)) {
    foreach ( $result->roles as $key=> $item) {
      if ( isset ($item->item) ) {
        foreach ( $item->item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      } else {
        foreach ( $item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      }

      $rows[$i++] = array ( 'guid' => $guid, 'name' => $name );
    }
  }
  return $rows;
}
/**
 * method
 *
 * Returns a list of the cases which the current logged-in user has privileges to
 * open.
 *
 * @name WSCaseList
 * label WS Case List
 * Link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSCaseList.28.29
 *
 * @return array | $rows | List of the cases |It returns a list of cases
 *
 */
function WSCaseList() {
  $client = WSOpen();

  $sessionId = $_SESSION['WS_SESSION_ID'];
  $params = array('sessionId'=>$sessionId );
  $result = $client->__SoapCall('CaseList', array($params));

  $i = 1;
  if(isset ($result->cases)) {
    foreach ( $result->cases as $key=> $item) {
      if ( isset ($item->item) ) {
        foreach ( $item->item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      } else {
        foreach ( $item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      }

      $rows[$i++] = array ( 'guid' => $guid, 'name' => $name );
    }
  }

  return $rows;
}
/**
 * method
 *
 * Returns a list of processes in the current workspace.
 *
 * @name WSProcessList
 * label WS Process List
 * Link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSProcessList.28.29
 *
 * @return array | $rows | List of processes | A list of processes
 *
 */
function WSProcessList() {
  $client = WSOpen();

  $sessionId = $_SESSION['WS_SESSION_ID'];
  $params = array('sessionId'=>$sessionId );
  $result = $client->__SoapCall('ProcessList', array($params));

  $i = 1;
  if(isset ($result->processes)) {
    foreach ( $result->processes as $key=> $item) {
      if ( isset ($item->item) ) {
        foreach ( $item->item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      } else {
        foreach ( $item as $index=> $val ) {
          if ( $val->key == 'guid' ) $guid = $val->value;
          if ( $val->key == 'name' ) $name = $val->value;
        }
      }

      $rows[$i++] = array ( 'guid' => $guid, 'name' => $name );
    }
  }
  return $rows;
}
/**
 * method
 *
 * Returns a list of processes in the current workspace.
 *
 * @name getEmailConfiguration
 * label WS Get Email Configuration
 *
 *
 * @return array | $aFields | Array |Get current email configuration
 *
 */
//private function to get current email configuration
function getEmailConfiguration () {
  require_once 'classes/model/Configuration.php';
  $oConfiguration = new Configuration();
  $sDelimiter     = DBAdapter::getStringDelimiter();
  $oCriteria      = new Criteria('workflow');
  $oCriteria->add(ConfigurationPeer::CFG_UID, 'Emails');
  $oCriteria->add(ConfigurationPeer::OBJ_UID, '');
  $oCriteria->add(ConfigurationPeer::PRO_UID, '');
  $oCriteria->add(ConfigurationPeer::USR_UID, '');
  $oCriteria->add(ConfigurationPeer::APP_UID, '');

  if (ConfigurationPeer::doCount($oCriteria) == 0) {
    $oConfiguration->create(array('CFG_UID' => 'Emails', 'OBJ_UID' => '', 'CFG_VALUE' => '', 'PRO_UID' => '', 'USR_UID' => '', 'APP_UID' => ''));
    $aFields = array();
  }
  else {
    $aFields = $oConfiguration->load('Emails', '', '', '', '');
    if ($aFields['CFG_VALUE'] != '') {
      $aFields = unserialize($aFields['CFG_VALUE']);
    }
    else {
      $aFields = array();
    }
  }

  return $aFields;
}

/**
 * method
 *
 * Sends an email using a template file.
 *
 * @name PMFSendMessage
 * label PMF Send Message
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFSendMessage.28.29
 *
 * @param string(32) | $caseId | UID for case | The UID (unique identification) for a case, which is a string of 32 hexadecimal characters to identify the case.
 * @param string(32) | $sFrom | Email addres | The email address of the person who sends out the email.
 * @param string(32) | $sTo | Email receptor | The email address(es) to whom the email is sent. If multiple recipients, separate each email address with a semicolon.
 * @param string(32) | $sCc | Email addres for copies | The email address(es) of people who will receive carbon copies of the email.
 * @param string(32) | $sBcc | Email addres for copies hidden | The email address(es) of people who will receive blind carbon copies of the email.
 * @param string(32) | $sSubject | Subject of the email | The subject (title) of the email.
 * @param string(32) | $sTemplate | Name of the template | The name of the template file in plain text or HTML format which will produce the body of the email.
 * @param array | $aFields=array() | An associative array optional | Optional parameter. An associative array where the keys are the variable name and the values are the variable's value.
 * @return int | $result | result | Result of sending email
 *
 */
function PMFSendMessage($caseId, $sFrom, $sTo, $sCc, $sBcc, $sSubject, $sTemplate, $aFields = array()) {
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->sendMessage($caseId, $sFrom, $sTo, $sCc, $sBcc, $sSubject, $sTemplate, $aFields);

  if ( $result->status_code == 0) {
    return 1;
  } else {
    return 0;
  }
}

/**
 * method
 *
 * Sends two variables to the specified case.
 * It will create new case variables if they don't already exist
 *
 * @name WSSendVariables
 * label WS Send Variables
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSSendVariables.28.29
 *
 * @param string(32) | $caseId | UID for case | The unique ID of the case which will receive the variables.
 * @param string(32) | $name1 | Name of the first variable | The name of the first variable to be sent to the created case.
 * @param string(32) | $value1 | Value of the first variable | The value of the first variable to be sent to the created case.
 * @param string(32) | $name2 | Name of the second variable | The name of the second variable to be sent to the created case.
 * @param string(32) | $value2 | Value of the second variable | The value of the second variable to be sent to the created case.
 * @return array | $fields | WS Response Associative Array: | The function returns a WS Response associative array.
 *
 */
function WSSendVariables($caseId, $name1, $value1, $name2, $value2) {
  $client = WSOpen();
  $sessionId = $_SESSION['WS_SESSION_ID'];

  $variables[1]->name  = $name1;
  $variables[1]->value = $value1;
  $variables[2]->name  = $name2;
  $variables[2]->value = $value2;
  $params = array('sessionId'=>$sessionId, 'caseId'=>$caseId, 'variables'=>$variables);
  $result = $client->__SoapCall('SendVariables', array($params));

  $fields['status_code'] = $result->status_code;
  $fields['message']     = $result->message;
  $fields['time_stamp']  = $result->timestamp;
  return $fields;
}
/**
 * method
 *
 * Routes (derivates) a case, moving the case to the next task in the process
 * according its routing rules.
 *
 * @name WSDerivateCase
 * label WS Derivate Case
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSDerivateCase.28.29
 *
 * @param string(32) | $CaseId | Case ID |The unique ID for a case, which can be found with WSCaseList() or by examining the field wf_<WORKSPACE>.APPLICATION.APP_UID.
 * @param string(32) | $delIndex | Delegation index for the task | The delegation index for the task, which can be found by examining the field wf_<WORKSPACE>.APP_DELEGATION.DEL_INDEX.
 * @return array | $fields | WS Response Associative Array | A WS Response associative array.
 *
 */
function WSDerivateCase($caseId, $delIndex) {
  $client = WSOpen();
  $sessionId = $_SESSION['WS_SESSION_ID'];

  $params = array('sessionId'=>$sessionId, 'caseId'=>$caseId, 'delIndex'=>$delIndex );
  $result = $client->__SoapCall('DerivateCase', array($params));

  $fields['status_code'] = $result->status_code;
  $fields['message']     = $result->message;
  $fields['time_stamp']  = $result->timestamp;
  return $fields;
}
/**
 * method
 *
 * Creates a case with any user with two initial case variables.
 *
 * @name WSNewCaseImpersonate
 * label WS New Case Impersonate
 * @link  http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSNewCaseImpersonate.28.29
 *
 * @param string(32) | $processId | Process ID | The unique ID for the process.
 * @param string(32) | $userId | User ID | The unique ID for the user.
 * @param string(32) | $name1 | Name of the first variable  | The name of the first variable to be sent to the created case.
 * @param string(32) | $value1 | Value of the first variable | The value of the first variable to be sent to the created case.
 * @param string(32) | $name2 | Name of the second variable | The name of the second variable to be sent to the created case.
 * @param string(32) | $value2 | Value of the second variable | The value of the second variable to be sent to the created case.
 * @return array | $fields | WS Response Associative Array | A WS Response associative array.
 *
 */
function WSNewCaseImpersonate($processId, $userId, $name1, $value1, $name2, $value2) {
  $client = WSOpen();
  $sessionId = $_SESSION['WS_SESSION_ID'];

  $variables[1]->name  = $name1;
  $variables[1]->value = $value1;
  $variables[2]->name  = $name2;
  $variables[2]->value = $value2;

  $params = array('sessionId'=>$sessionId, 'processId'=>$processId, 'userId'=>$userId, 'variables'=>$variables );
  $result = $client->__SoapCall('NewCaseImpersonate', array($params));

  $fields['status_code'] = $result->status_code;
  $fields['message']     = $result->message;
  $fields['time_stamp']  = $result->timestamp;
  return $fields;
}
/**
 * method
 *
 * Creates a new case starting with a specified task and using two initial case
 * variables.
 *
 * @name WSNewCase
 * label WS New Case
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSNewCase.28.29
 *
 * @param string(32) | $processId | Process ID | The unique ID for the process. To use the current process, use the system variable @@PROCESS.
 * @param string(32) | $userId | User ID | The unique ID for the user. To use the currently logged-in user, use the system variable @@USER_LOGGED.
 * @param string(32) | $name1 | Name of the first variable  | The name of the first variable to be sent to the created case.
 * @param string(32) | $value1 | Value of the first variable | The value of the first variable to be sent to the created case.
 * @param string(32) | $name2 | Name of the second variable | The name of the second variable to be sent to the created case.
 * @param string(32) | $value2 | Value of the second variable | The value of the second variable to be sent to the created case.
 * @return array | $fields | WS array | A WS Response associative array.
 *
 */
function WSNewCase($processId, $taskId, $name1, $value1, $name2, $value2) {
  $client = WSOpen();
  $sessionId = $_SESSION['WS_SESSION_ID'];

  $variables[1]->name  = $name1;
  $variables[1]->value = $value1;
  $variables[2]->name  = $name2;
  $variables[2]->value = $value2;

  $params = array('sessionId'=>$sessionId, 'processId'=>$processId, 'taskId'=>$taskId, 'variables'=>$variables );
  $result = $client->__SoapCall('NewCase', array($params));

  $fields['status_code'] = $result->status_code;
  $fields['message']     = $result->message;
  $fields['time_stamp']  = $result->timestamp;
  return $fields;
}
/**
 * method
 *
 * Assigns a user to a group (as long as the logged in user has the PM_USERS
 * permission in their role).
 *
 * @name WSAssignUserToGroup
 * label WS Assign User To Group
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSAssignUserToGroup.28.29
 *
 * @param string(32) | $userId | User ID | The unique ID for a user.
 * @param string(32) | $groupId | Group ID | The unique ID for a group.
 * @return array | $fields | WS array |A WS Response associative array.
 *
 */
function WSAssignUserToGroup($userId, $groupId) {
  $client = WSOpen();
  $sessionId = $_SESSION['WS_SESSION_ID'];

  $params = array('sessionId'=>$sessionId, 'userId'=>$userId, 'groupId'=>$groupId);
  $result = $client->__SoapCall('AssignUserToGroup', array($params));

  $fields['status_code'] = $result->status_code;
  $fields['message']     = $result->message;
  $fields['time_stamp']  = $result->timestamp;
  return $fields;
}
/**
 * method
 *
 * Creates a new user in ProcessMaker.
 *
 * @name WSCreateUser
 * label WS Create User
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSCreateUser.28.29
 *
 * @param string(32) | $userId | User ID | The username of the new user, which can be up to 32 characters long.
 * @param string(32) | $password | Password of the new user | El password of the new user, which can be up to 32 characters long.
 * @param string(32) | $firstname | Firstname of the new user | The first name(s) of the new user, which can be up to 50 characters long.
 * @param string(32) | $lastname | Lastname of the new user | The last name(s) of the new user, which can be up to 50 characters long.
 * @param string(32) | $email | Email the new user | The e-mail of the new user, which can be up to 100 characters long.
 * @param string(32) | $role | Rol of the new user | The role of the new user, such as 'PROCESSMAKER_ADMIN' and 'PROCESSMAKER_OPERATOR'.
 * @return array | $fields | WS array | A WS Response associative array.
 *
 */
function WSCreateUser($userId, $password, $firstname, $lastname, $email, $role) {
  $client = WSOpen();
  $sessionId = $_SESSION['WS_SESSION_ID'];
  $params = array('sessionId'=>$sessionId, 'userId'=>$userId, 'firstname'=>$firstname, 'lastname'=>$lastname, 'email'=>$email, 'role'=>$role, 'password'=>$password);
  $result = $client->__SoapCall('CreateUser', array($params));

  $fields['status_code'] = $result->status_code;
  $fields['message']     = $result->message;
  $fields['time_stamp']  = $result->timestamp;
  return $fields;
}
/**
 * method
 *
 * Returns the unique ID for the current active session.
 *
 * @name WSGetSession
 * label WS Get Session
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#WSGetSession.28.29
 *
 * @return string | $userId | Sesion ID | The unique ID for the current active session.
 *
 */
function WSGetSession() {
  if(isset($_SESSION['WS_SESSION_ID'])) {
    return $_SESSION['WS_SESSION_ID'];
  } else {
    throw new Exception("SW session is not open!");
  }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/** Local Services Functions **/

/**
 * method
 *
 * Returns all the tasks for the specified case which have open delegations.
 *
 * @name PMFTaskCase
 * label PMF Task Case
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFTaskCase.28.29
 *
 * @param string(32) | $caseId | Case ID | The unique ID for a case.
 * @return array | $rows | List of tasks | A list of tasks
 *
 */
function PMFTaskCase($caseId) #its test was successfull
{
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->taskCase($caseId);
  $rows = Array();
  $i = 1;
  if(isset ($result)) {
    foreach ( $result as $item) {
      $rows[$i++] = $item;
    }
  }
  return $rows;
}
/**
 * method
 *
 * Returns a list of tasks which the specified user has initiated.
 *
 * @name PMFTaskList
 * label PMF Task List
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFTaskList.28.29
 *
 * @param string(32) | $userid | User ID | The unique ID of a user.
 * @return array | $rows | List of tasks | An array of tasks
 *
 */
function PMFTaskList($userId) #its test was successfull
{
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->taskList($userId);
  $rows = Array();
  $i = 1;
  if(isset ($result)) {
    foreach ( $result as $item) {
      $rows[$i++] = $item;
    }
  }
  return $rows;
}
/**
 * method
 *
 * Returns a list of users whose status is set to "ACTIVE" for the current workspace.
 *
 * @name PMFUserList
 * label PMF User List
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFUserList.28.29
 *
 * @return array | $rows | List of users | An array of users
 *
 */
function PMFUserList() #its test was successfull
{
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->userList();
  $rows = Array();
  $i = 1;
  if(isset ($result)) {
    foreach ( $result as $item) {
      $rows[$i++] = $item;
    }
  }
  return $rows;
}
/**
 * method
 *
 * Generates an Output Document
 *
 * @name PMFGenerateOutputDocument
 * label PMF Generate Output Document
 *
 * @param string(32) | $outputID | Output ID | Output Document ID
 * @return none | $none | None | None
 *
 */
function PMFGenerateOutputDocument($outputID) {

  $oCase = new Cases();
  $oCase->thisIsTheCurrentUser($_SESSION['APPLICATION'], $_SESSION['INDEX'], $_SESSION['USER_LOGGED'], 'REDIRECT', 'cases_List');

  $oOutputDocument = new OutputDocument();
  $aOD = $oOutputDocument->load($outputID);

  $Fields = $oCase->loadCase( $_SESSION['APPLICATION'] );

  $sFilename = ereg_replace('[^A-Za-z0-9_]', '_', G::replaceDataField($aOD['OUT_DOC_FILENAME'], $Fields['APP_DATA']));

  if ( $sFilename == '' ) $sFilename='_';

  $sFilename = ereg_replace('[^A-Za-z0-9_]', '_', G::replaceDataField($aOD['OUT_DOC_FILENAME'], $Fields['APP_DATA']));
  if ( $sFilename == '' ) $sFilename='_';
  $pathOutput = PATH_DOCUMENT . $_SESSION['APPLICATION'] . PATH_SEP . 'outdocs'. PATH_SEP ;
  G::mk_dir ( $pathOutput );

  $oOutputDocument->generate( $outputID, $Fields['APP_DATA'], $pathOutput, $sFilename, $aOD['OUT_DOC_TEMPLATE'], (boolean)$aOD['OUT_DOC_LANDSCAPE'] );

} 
/**
 * method
 *
 * Returns a list of groups from the current workspace
 *
 * @name PMFGroupList
 * label PMF Group List
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFGroupList.28.29
 *
 * @return array | $rows | List of groups | An array of groups
 *
 */
function PMFGroupList() #its test was successfull
{
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->groupList();
  $rows = Array();
  $i = 1;
  if(isset ($result)) {
    foreach ( $result as $item) {
      $rows[$i++] = $item;
    }
  }
  return $rows;
}

/**
 * method
 *
 * Returns a list of roles whose status is "ACTIVE" for the current workspace.
 *
 * @name PMFRoleList
 * label PMF Role List
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFRoleList.28.29
 *
 * @return array | $rows | List of roles | This function returns an array of roles
 *
 */
function PMFRoleList() #its test was successfull
{
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->roleList();
  $rows = Array();
  $i = 1;
  if(isset ($result)) {
    foreach ( $result as $item) {
      $rows[$i++] = $item;
    }
  }
  return $rows;
}
/**
 * method
 *
 * Returns a list of the pending cases for a specified user
 *
 * @name PMFCaseList
 * label PMF Case List
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFCaseList.28.29
 *
 * @param string(32) | $userId | User ID | The unique ID of a user who is assigned to work on the cases.
 * @return array | $rows | List of cases | A list of cases
 *
 */
function PMFCaseList($userId) #its test was successfull
{
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->caseList($userId);
  $rows = Array();
  $i = 1;
  if(isset ($result)) {
    foreach ( $result as $item) {
      $rows[$i++] = $item;
    }
  }
  return $rows;
}
/**
 * method
 *
 * Returns a list of processes for the current workspace
 *
 * @name PMFProcessList
 * label PMF Process List
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFProcessList.28.29
 *
 * @return array | $rows | Lis ot Processes | An array of tasks in the indicated case which have open delegations
 *
 */
function PMFProcessList() #its test was successfull
{
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->processList();
  $rows = Array();
  $i = 1;
  if(isset ($result)) {
    foreach ( $result as $item) {
      $rows[$i++] = $item;
    }
  }
  return $rows;
}

/**
 * method
 *
 * Sends an array of case variables to a specified case.
 *
 * @name PMFSendVariables
 * label PMF Send Variables
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFSendVariables.28.29
 *
 * @param string(32) | $caseId | Case ID | The unique ID of the case to receive the variable.
 * @param array | $variables | Array of variables | An associative array to hold the case variables to send to the case.
 * @return int | $result | Result of send variables | Returns 1 if the variables were sent successfully to the case; otherwise, returns 0 if an error occurred.
 *
 */
function PMFSendVariables($caseId, $variables) {
  G::LoadClass('wsBase');
  $ws = new wsBase ();

  $result = $ws->sendVariables($caseId, $variables);
  if($result->status_code == 0) {
    return 1;
  } else {
    return 0;
  }
}
/**
 * method
 *
 * Derivates (routes) a case to the next task in the process.
 *
 * @name PMFDerivateCase
 * label PMF Derivate Case
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFDerivateCase.28.29
 *
 * @param string(32) | $caseId | Case ID | The unique ID for the case to be derivated (routed)
 * @param int | $delIndex | delegation index for the case  | The delegation index for the case to derivated (routed).
 * @param boolean | $bExecuteTriggersBeforeAssignment = false | Trigger | Optional parameter. If set to true, any triggers which are assigned to pending steps in the current task will be executed before the case is assigned to the next user.
 * @return int | $result | Result of Derivate case | Returns 1 if new case was derivated (routed) successfully; otherwise, returns 0 if an error occurred.
 *
 */
function PMFDerivateCase($caseId, $delIndex, $bExecuteTriggersBeforeAssignment = false) {
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->derivateCase($_SESSION['USER_LOGGED'], $caseId, $delIndex, $bExecuteTriggersBeforeAssignment);//var_dump($result);die;
  if (isset($result->status_code)) {
    return $result->status_code;
  }
  else {
    return 0;
  }
  if($result->status_code == 0) {
    return 1;
  } else {
    return 0;
  }
}
/**
 * method
 *
 * Creates a new case with a user who can impersonate a user with the proper
 * privileges.
 *
 * @name PMFNewCaseImpersonate
 * label PMF New Case Impersonate
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFNewCaseImpersonate.28.29
 *
 * @param string(32) | $processId | Process ID | The unique ID of the process.
 * @param string(32) | $userId | User ID | The unique ID of the user.
 * @param array | $variables | Array of variables | An associative array of the variables which will be sent to the case.
 * @return int | $result | Result | Returns 1 if new case was created successfully; otherwise, returns 0 if an error occurred.
 *
 */
function PMFNewCaseImpersonate($processId, $userId, $variables) {
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->newCaseImpersonate($processId, $userId, $variables);

  if($result->status_code == 0) {
    return 1;
  } else {
    return 0;
  }
}
/**
 * method
 *
 * Creates a new case starting with the specified task
 *
 * @name PMFNewCase
 * label PMF New Case
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFNewCase.28.29
 *
 * @param string(32) | $processId | Process ID | The unique ID of the process.
 * @param string(32) | $userId | User ID | The unique ID of the user.
 * @param string(32) | $taskId | Task ID | The unique ID of the task.
 * @param array | $variables | Array of variables | An associative array of the variables which will be sent to the case.
 * @return string | $idNewCase | Case ID | If an error occured, it returns the integer zero. Otherwise, it returns a string with the case UID of the new case.
 *
 */
function PMFNewCase($processId, $userId, $taskId, $variables) {
  G::LoadClass('wsBase');
  $ws = new wsBase ();

  $result = $ws->newCase($processId, $userId,$taskId, $variables);

  if($result->status_code == 0) {
    return $result->caseId;
  } else {
    return 0;
  }
}
/**
 * method
 *
 * Assigns a user to a group.
 *
 * @name PMFAssignUserToGroup
 * label PMF Assign User To Group
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFNewCase.28.29
 *
 * @param string(32) | $userId | User ID | The unique ID of the user.
 * @param string(32) | $groupId | Group ID | The unique ID of the group.
 * @return int | $result | Result of the assignment | Returns 1 if the user was successfully assigned to the group; otherwise, returns 0.
 *
 */
function PMFAssignUserToGroup($userId, $groupId) {
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->assignUserToGroup($userId, $groupId);

  if($result->status_code == 0) {
    return 1;
  } else {
    return 0;
  }
}
/**
 * method
 *
 * Creates a new user with the given data.
 *
 * @name PMFCreateUser
 * label PMF Create User
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFCreateUser.28.29
 *
 * @param string(32) | $userId | User ID | The username for the new user.
 * @param string(32) | $password | Password of the new user  | The password of the new user, which can be up to 32 characters long.
 * @param string(32) | $firstname | Firstname of the new user | The first name of the user, which can be up to 50 characters long.
 * @param string(32) | $lastname | Lastname of the new user | The last name of the user, which can be up to 50 characters long.
 * @param string(32) | $email | Email the new user | The email of the new user, which can be up to 100 characters long.
 * @param string(32) | $role | Rol of the new user | The role of the new user such as 'PROCESSMAKER_ADMIN' or 'PROCESSMAKER_OPERATOR'.
 * @return int | $result | Result of the creation | Returns 1 if the new user was created successfully; otherwise, returns 0 if an error occurred.
 *
 */
function PMFCreateUser($userId, $password, $firstname, $lastname, $email, $role) {
  G::LoadClass('wsBase');
  $ws = new wsBase ();
  $result = $ws->createUser($userId, $firstname, $lastname, $email, $role, $password);

  if($result->status_code == 0) {
    return 1;
  } else {
    return 0;
  }
}
/**
 * method
 *
 * Creates a random string of letters and/or numbers of a specified length,which
 * can be used as the PINs (public identification numbers) and codes for cases.
 *
 * @name generateCode
 * label generate Code
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#generateCode.28.29
 *
 * @param int | $iDigits = 4 | Number of characters | The number of characters to be generated.
 * @param string(32) | $sType="NUMERIC" | Type of characters | The type of of characters to be generated
 * @return string | $generateString | Generated string | The generated string of random characters.
 *
 */
function generateCode ( $iDigits = 4, $sType = 'NUMERIC' ) {
  return G::generateCode ($iDigits, $sType );
}

/**
 * method
 *
 * Sets the code and PIN for a case.
 *
 * @name setCaseTrackerCode
 * label set Case Tracker Code
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#setCaseTrackerCode.28.29
 *
 * @param string(32) | $sApplicationUID | Case ID | The unique ID for a case (which can be found with WSCaseList()
 * @param string(32) | $sCode | New Code for case | The new code for a case, which will be stored in the field wf_<WORKSPACE>.APPLICATION.APP_CODE
 * @param string(32) | $sPIN = "" | New Code PIN for case |The new code for a case.
 * @return int | $result | Result | If successful, returns zero, otherwise a non-zero error number.
 *
 */
function setCaseTrackerCode($sApplicationUID, $sCode, $sPIN = '') {
  if ($sCode != '') {
    G::LoadClass('case');
    $oCase   = new Cases();
    $aFields = $oCase->loadCase($sApplicationUID);
    $aFields['APP_PROC_CODE'] = $sCode;
    if ($sPIN != '') {
      $aFields['APP_DATA']['PIN'] = $sPIN;
      $aFields['APP_PIN']         = md5($sPIN);
    }
    $oCase->updateCase($sApplicationUID, $aFields);
    return 1;
  }
  else {
    return 0;
  }
}
/**
 * method
 *
 * Routes (derivates) a case and then displays the case list.
 *
 * @name jumping
 * label jumping
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#jumping.28.29
 *
 * @param string(32) | $caseId | Case ID | The unique ID for the case to be routed (derivated).
 * @param int | $delIndex | delegation Index of case | The delegation index of the task to be routed (derivated). Counting starts from 1.
 * @return none | $none | None | None
 *
 */
function jumping ( $caseId, $delIndex ) {
  $x = $this->PMFDerivateCase($caseId, $delIndex);
  if($x==0)
    G::SendTemporalMessage('ID_NOT_DERIVATED', 'error', 'labels');

  G::header('Location: cases_List');
}
/**
 * method
 *
 * Returns the label of a specified option from a dropdown box, listbox,
 * checkgroup or radiogroup.
 *
 * @name PMFgetLabelOption
 * label PMF get Label Option
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFgetLabelOption.28.29
 *
 * @param string(32) | $PROCESS | Process ID | The unique ID of the process which contains the field.
 * @param string(32) | $DYNAFORM_UID | Dynaform ID | The unique ID of the DynaForm where the field is located.
 * @param string(32) | $FIELD_NAME | Fiel Name | The field name of the dropdown box, listbox, checkgroup or radiogroup from the specified DynaForm.
 * @param string(32) | $FIELD_SELECTED_ID | ID selected | The value (i.e., ID) of the option from the fieldName.
 * @return string | $label | Label of the specified option | A string holding the label of the specified option or NULL if the specified option does not exist.
 *
 */
function PMFgetLabelOption($PROCESS, $DYNAFORM_UID, $FIELD_NAME, $FIELD_SELECTED_ID) {
  $G_FORM = new Form ("{$PROCESS}/{$DYNAFORM_UID}", PATH_DYNAFORM, SYS_LANG, false);
  if( isset($G_FORM->fields[$FIELD_NAME]->option[$FIELD_SELECTED_ID]) ) {
    return $G_FORM->fields[$FIELD_NAME]->option[$FIELD_SELECTED_ID];
  } else {
    return null;
  }
}
/**
 * method
 *
 * Redirects a case to any step in the current task. In order for the step to
 * be executed, the specified step much exist and if it contains a condition,
 * it must evaluate to true.
 *
 * @name PMFRedirectToStep
 * label PMF Redirect To Step
 * @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFRedirectToStep.28.29
 *
 * @param string(32) | $sApplicationUID | Case ID | The unique ID for a case,
 * @param int | $iDelegation | Delegation index | The delegation index of a case.
 * @param string(32) | $sStepType | Type of Step | The type of step, which can be "DYNAFORM", "INPUT_DOCUMENT" or "OUTPUT_DOCUMENT".
 * @param string(32) | $sStepUid | Step ID | The unique ID for the step.
 * @return none | $none | None | None
 *
 */
function PMFRedirectToStep($sApplicationUID, $iDelegation, $sStepType, $sStepUid) {
  require_once 'classes/model/AppDelegation.php';
  $oCriteria = new Criteria('workflow');
  $oCriteria->addSelectColumn(AppDelegationPeer::TAS_UID);
  $oCriteria->add(AppDelegationPeer::APP_UID, $sApplicationUID);
  $oCriteria->add(AppDelegationPeer::DEL_INDEX, $iDelegation);
  $oDataset = AppDelegationPeer::doSelectRS($oCriteria);
  $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
  $oDataset->next();
  $aRow = $oDataset->getRow();
  if ($aRow) {
    require_once 'classes/model/Step.php';
    $oStep = new Step();
    $oTheStep = $oStep->loadByType($aRow['TAS_UID'], $sStepType, $sStepUid);
    $bContinue = true;
    if ($oTheStep->getStepCondition() != '') {
      G::LoadClass('case');
      $oCase   = new Cases();
      $aFields = $oCase->loadCase($sApplicationUID);
      G::LoadClass('pmScript');
      $oPMScript = new PMScript();
      $oPMScript->setFields($aFields['APP_DATA']);
      $oPMScript->setScript($oTheStep->getStepCondition());
      $bContinue = $oPMScript->evaluate();
    }
    if ($bContinue) {
      switch ($oTheStep->getStepTypeObj()) {
        case 'DYNAFORM':
          $sAction = 'EDIT';
          break;
        case 'OUTPUT_DOCUMENT':
          $sAction = 'GENERATE';
          break;
        case 'INPUT_DOCUMENT':
          $sAction = 'ATTACH';
          break;
        case 'EXTERNAL':
          $sAction = 'EDIT';
          break;
        case 'MESSAGE':
          $sAction = '';
          break;
      }
      G::header('Location: ' . 'cases_Step?TYPE=' . $sStepType . '&UID=' . $sStepUid . '&POSITION=' . $oTheStep->getStepPosition() . '&ACTION=' . $sAction);
      die;
    }
  }
}

/**
 * method
 *
 * Returns a list of the next assigned users to a case.
 *
 * @name PMFGetNextAssignedUsers
 * label PMFGet Next Assigned Users
 *
 * @param string(32) | $application | Case ID | Id of the case
 * @return array | $array | List of users | Return a list of users
 *
 */
function PMFGetNextAssignedUsers ($application) {

  require_once 'classes/model/AppDelegation.php';
  require_once 'classes/model/Task.php';
  require_once 'classes/model/TaskUser.php';
  require_once 'classes/model/Users.php';

  $oCriteria = new Criteria('workflow');

  $oCriteria->addSelectColumn(AppDelegationPeer::PRO_UID);
  $oCriteria->add(AppDelegationPeer::APP_UID, $application);
  $oDataset = AppDelegationPeer::doSelectRS($oCriteria);
  $oDataset->next();
  $aRow = $oDataset->getRow();
  $PRO_UID=$aRow[0];

  $c = new Criteria('workflow');
  $c->addSelectColumn(TaskPeer::TAS_UID);
  $c->add(TaskPeer::PRO_UID, $PRO_UID);
  $c->add(TaskPeer::TAS_LAST_ASSIGNED, 0);
  $oDataset = TaskPeer::doSelectRS($c);
  $oDataset->next();
  $aRow = $oDataset->getRow();
  $TAS_UID=$aRow[0];


  $k=new Criteria('workflow');
  $k->addSelectColumn(TaskUserPeer::USR_UID);
  $k->add(TaskUserPeer::TAS_UID,$TAS_UID);
  $k->add(TaskUserPeer::TU_TYPE,1);
  $ods=TaskUserPeer::doSelectRS($k);
  $ods->next();
  $row=$ods->getRow();
  $USR_UID=$row[0];

  $kk=new Criteria();
  $kk->addSelectColumn(UsersPeer::USR_UID);
  $kk->addSelectColumn(UsersPeer::USR_USERNAME);
  $kk->addSelectColumn(UsersPeer::USR_FIRSTNAME);
  $kk->addSelectColumn(UsersPeer::USR_LASTNAME);
  $kk->addSelectColumn(UsersPeer::USR_EMAIL);
  $kk->add(UsersPeer::USR_UID,$USR_UID);
  $oDataset=UsersPeer::doSelectRS($kk);
  $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
  $oDataset->next();

  $aRow1 = $oDataset->getRow();

  $array=array(
          'USR_UID'      => $aRow1['USR_UID'],
          'USR_USERNAME' => $aRow1['USR_USERNAME'],
          'USR_FIRSTNAME'=> $aRow1['USR_FIRSTNAME'],
          'USR_LASTNAME' => $aRow1['USR_LASTNAME'],
          'USR_EMAIL'    => $aRow1['USR_EMAIL']
  );

  return ($array);

}


//new functions by Erik

function PMFGetUserEmailAddress($id, $APP_UID=null, $prefix='usr') {
  
  require_once 'classes/model/UsersPeer.php';
  require_once 'classes/model/AppDelegation.php';
  G::LoadClass('case');

  if( is_string($id) && trim($id) == "" ){
    return false;
  }
  if( is_array($id) && count($id) == 0 ){
    return false;
  }


  //recipient to store the email addresses
  $aRecipient = Array();
  $aItems = Array();
  
  /*
   * First at all the $id user input can be by example erik@colosa.com
   * 2. this $id param can be a array by example Array('000000000001', '000000000002')  in this case $prefix is necessary
   * 3. this same param can be a array by example Array('usr|000000000001', 'usr|-1', 'grp|2245141479413131441')
   */

  /*
   * The second thing is that the return type will be configurated depend of the input type (using $retType)
   */
  if( is_array($id) ){
    $aItems = $id;
    $retType = 'array';
  } else {
    $retType = 'string';
    if( strpos($id, ",") !== false ){
      $aItems = explode(',', $id);
    } else {
      array_push($aItems, $id);
    }
  }
  
  foreach ($aItems as $sItem) {
    //cleaning for blank spaces into each array item
    $sItem = trim($sItem);
    if( strpos($sItem, "|") !== false ){
      //explode the parameter because  always will be compose with pipe separator to indicate the type (user or group) and the target mai
      list($sType, $sID) = explode('|', $sItem);
      $sType = trim($sType);
      $sID   = trim($sID);
    } else {
      $sType = $prefix;
      $sID = $sItem;
    }

    switch($sType) {
      case 'ext':
        if( G::emailAddress($sID) ) {
          array_push($aRecipient, $sID);
        }
      break;
      case 'usr':
        if ($sID == '-1') { // -1: Cuurent user, load from user record
          if( isset($APP_UID) ){
            $oAppDelegation = new AppDelegation;
            $aAppDel = $oAppDelegation->getLastDeleration($APP_UID);
            if(isset($aAppDel)){
              $oUserRow = UsersPeer::retrieveByPK($aAppDel['USR_UID']);
              if( isset($oUserRow) ){
                $sID = $oUserRow->getUsrEmail();
              } else {
                throw new Exception('User with ID '.$oAppDelegation->getUsrUid(). 'doesn\'t exist');
              }
              if( G::emailAddress($sID) ) {
                array_push($aRecipient, $sID);
              }
            }
          }
        } else {
          $oUserRow = UsersPeer::retrieveByPK($sID);
          $sID = $oUserRow->getUsrEmail();
          if( G::emailAddress($sID) ) {
            array_push($aRecipient, $sID);
          } 
        }
        
        break;

      case 'grp':
        G::LoadClass('groups');
        $oGroups = new Groups();
        $oCriteria = $oGroups->getUsersGroupCriteria($sID);
        $oDataset = GroupwfPeer::doSelectRS($oCriteria);
        $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
        while ($oDataset->next()) {
          $aGroup = $oDataset->getRow();
          //to validate email address
          if( G::emailAddress($aGroup['USR_EMAIL']) ) {
            array_push($aRecipient, $aGroup['USR_EMAIL']);
          }
        }

        break;

      case 'dyn':
        $oCase = new Cases();
        $aFields = $oCase->loadCase($APP_UID);
        $aFields['APP_DATA'] = array_merge($aFields['APP_DATA'], G::getSystemConstants());
        
        //to validate email address
        if( isset($aFields['APP_DATA'][$sID]) && G::emailAddress($aFields['APP_DATA'][$sID]) ) {
          array_push($aRecipient, $aFields['APP_DATA'][$sID]);
        }
        break;
    }
  }

  switch($retType){
    case 'array':
      return $aRecipient;
    
    case 'string':
      return implode(',', $aRecipient);

    default:
      return $aRecipient;
  }
}