fernando/luos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
561832bb06c5cd89ed6d39b9a94003a53b897ab0
luos/workflow/engine/classes/class.pmFunctions.php
Marco Antonio Nina 51977f4504 BUG 7650 Function PMFRedirectToStep didnt work properly SOLVED 
- In the triggers do not run properly because it addresses before saving the data
- Data is captured and stored before redirect
2012-03-06 19:17:16 -04:00

1924 lines
66 KiB
PHP
Executable File
Raw Blame History

<?php
/**
* class.pmFunctions.php
*
* ProcessMaker Open Source Edition
* Copyright (C) 2004 - 2008 Colosa Inc.23
*
* 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 != '') {
if(isset($_SESSION['WS_SESSION_ID']))
$_SESSION['WS_END_POINT'] = $endpoint;
}
if(isset($_SESSION['WS_SESSION_ID']))
return $_SESSION['WS_SESSION_ID'] = $result->message;
else
return $result->message;
} else {
if(isset($_SESSION['WS_SESSION_ID']))
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()
{
G::loadClass('system');
return System::getEmailConfiguration();
}
/**
* @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 | An optional associative array | Optional parameter. An associative array where the keys are the variable names and the values are the variables' values.
* @param array | $aAttachment | Attachment | An Optional arrray. An array of files (full paths) to be attached to the email.
* @return int | $result | result | Result of sending 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.
function PMFSendMessage($caseId, $sFrom, $sTo, $sCc, $sBcc, $sSubject, $sTemplate, $aFields = array(), $aAttachment = array()) {
G::LoadClass('wsBase');
$ws = new wsBase ();
$result = $ws->sendMessage($caseId, $sFrom, $sTo, $sCc, $sBcc, $sSubject, $sTemplate, $aFields, $aAttachment);
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, $sApplication = null, $index = null, $sUserLogged = null) {
if(!$sApplication){
$sApplication = $_SESSION['APPLICATION'];
}
if(!$index){
$index = $_SESSION['INDEX'];
}
if(!$sUserLogged){
$sUserLogged = $_SESSION['USER_LOGGED'];
}
G::LoadClass('case');
$oCase = new Cases();
$oCase->thisIsTheCurrentUser($sApplication, $index, $sUserLogged, '', 'cases_List');
// require_once 'classes/model/OutputDocument.php';
$oOutputDocument = new OutputDocument();
$aOD = $oOutputDocument->load($outputID);
$Fields = $oCase->loadCase( $sApplication );
// The $_GET['UID'] variable is used when a process executes.
// $_GET['UID']=($aOD['OUT_DOC_VERSIONING'])?$_GET['UID']:$aOD['OUT_DOC_UID'];
$sUID = ($aOD['OUT_DOC_VERSIONING'])?$_GET['UID']:$aOD['OUT_DOC_UID'];
$sFilename = preg_replace('[^A-Za-z0-9_]', '_', G::replaceDataField($aOD['OUT_DOC_FILENAME'], $Fields['APP_DATA']));
require_once 'classes/model/AppFolder.php';
require_once 'classes/model/AppDocument.php';
//Get the Custom Folder ID (create if necessary)
$oFolder=new AppFolder();
//$aOD['OUT_DOC_DESTINATION_PATH'] = ($aOD['OUT_DOC_DESTINATION_PATH']=='')?PATH_DOCUMENT . $_SESSION['APPLICATION'] . PATH_SEP . 'outdocs'. PATH_SEP:$aOD['OUT_DOC_DESTINATION_PATH'];
$folderId=$oFolder->createFromPath($aOD['OUT_DOC_DESTINATION_PATH'], $sApplication);
//Tags
$fileTags=$oFolder->parseTags($aOD['OUT_DOC_TAGS'], $sApplication);
//Get last Document Version and apply versioning if is enabled
$oAppDocument= new AppDocument();
$lastDocVersion=$oAppDocument->getLastDocVersion($sUID, $sApplication);
$oCriteria = new Criteria('workflow');
$oCriteria->add(AppDocumentPeer::APP_UID, $sApplication);
//$oCriteria->add(AppDocumentPeer::DEL_INDEX, $index);
$oCriteria->add(AppDocumentPeer::DOC_UID, $sUID);
$oCriteria->add(AppDocumentPeer::DOC_VERSION, $lastDocVersion);
$oCriteria->add(AppDocumentPeer::APP_DOC_TYPE, 'OUTPUT');
$oDataset = AppDocumentPeer::doSelectRS($oCriteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset->next();
if(($aOD['OUT_DOC_VERSIONING'])&&($lastDocVersion!=0)){//Create new Version of current output
$lastDocVersion++;
if ($aRow = $oDataset->getRow()) {
$aFields = array('APP_DOC_UID' => $aRow['APP_DOC_UID'],
'APP_UID' => $sApplication,
'DEL_INDEX' => $index,
'DOC_UID' => $outputID,
'DOC_VERSION' => $lastDocVersion+1,
'USR_UID' => $sUserLogged,
'APP_DOC_TYPE' => 'OUTPUT',
'APP_DOC_CREATE_DATE' => date('Y-m-d H:i:s'),
'APP_DOC_FILENAME' => $sFilename,
'FOLDER_UID' => $folderId,
'APP_DOC_TAGS' => $fileTags);
$oAppDocument = new AppDocument();
$oAppDocument->create($aFields);
$sDocUID = $aRow['APP_DOC_UID'];
}
}else{//No versioning so Update a current Output or Create new if no exist
if ($aRow = $oDataset->getRow()) { //Update
$aFields = array('APP_DOC_UID' => $aRow['APP_DOC_UID'],
'APP_UID' => $sApplication,
'DEL_INDEX' => $index,
'DOC_UID' => $outputID,
'DOC_VERSION' => $lastDocVersion,
'USR_UID' => $sUserLogged,
'APP_DOC_TYPE' => 'OUTPUT',
'APP_DOC_CREATE_DATE' => date('Y-m-d H:i:s'),
'APP_DOC_FILENAME' => $sFilename,
'FOLDER_UID' => $folderId,
'APP_DOC_TAGS' => $fileTags);
$oAppDocument = new AppDocument();
$oAppDocument->update($aFields);
$sDocUID = $aRow['APP_DOC_UID'];
}else{
//we are creating the appdocument row
//create
if($lastDocVersion==0) $lastDocVersion++;
$aFields = array('APP_UID' => $sApplication,
'DEL_INDEX' => $index,
'DOC_UID' => $outputID,
'DOC_VERSION' => $lastDocVersion,
'USR_UID' => $sUserLogged,
'APP_DOC_TYPE' => 'OUTPUT',
'APP_DOC_CREATE_DATE' => date('Y-m-d H:i:s'),
'APP_DOC_FILENAME' => $sFilename,
'FOLDER_UID' => $folderId,
'APP_DOC_TAGS' => $fileTags);
$oAppDocument = new AppDocument();
$aFields['APP_DOC_UID']=$sDocUID = $oAppDocument->create($aFields);
}
}
$sFilename = $aFields['APP_DOC_UID']. "_".$lastDocVersion;
$pathOutput = PATH_DOCUMENT . $sApplication . PATH_SEP . 'outdocs'. PATH_SEP ;//G::pr($sFilename);die;
G::mk_dir ( $pathOutput );
$aProperties = array();
if(!isset($aOD['OUT_DOC_MEDIA']))
$aOD['OUT_DOC_MEDIA'] = 'Letter';
if(!isset($aOD['OUT_DOC_LEFT_MARGIN']))
$aOD['OUT_DOC_LEFT_MARGIN'] = '15';
if(!isset($aOD['OUT_DOC_RIGHT_MARGIN']))
$aOD['OUT_DOC_RIGHT_MARGIN'] = '15';
if(!isset($aOD['OUT_DOC_TOP_MARGIN']))
$aOD['OUT_DOC_TOP_MARGIN'] = '15';
if(!isset($aOD['OUT_DOC_BOTTOM_MARGIN']))
$aOD['OUT_DOC_BOTTOM_MARGIN'] = '15';
$aProperties['media']=$aOD['OUT_DOC_MEDIA'];
$aProperties['margins']=array('left' => $aOD['OUT_DOC_LEFT_MARGIN'], 'right' => $aOD['OUT_DOC_RIGHT_MARGIN'], 'top' => $aOD['OUT_DOC_TOP_MARGIN'], 'bottom' => $aOD['OUT_DOC_BOTTOM_MARGIN'],);
$oOutputDocument->generate( $outputID, $Fields['APP_DATA'], $pathOutput, $sFilename, $aOD['OUT_DOC_TEMPLATE'], (boolean)$aOD['OUT_DOC_LANDSCAPE'], $aOD['OUT_DOC_GENERATE'] );
//Plugin Hook PM_UPLOAD_DOCUMENT for upload document
// G::LoadClass('plugin');
$oPluginRegistry =& PMPluginRegistry::getSingleton();
if ( $oPluginRegistry->existsTrigger ( PM_UPLOAD_DOCUMENT ) && class_exists ('uploadDocumentData' ) ) {
$triggerDetail=$oPluginRegistry->getTriggerInfo( PM_UPLOAD_DOCUMENT );
$aFields['APP_DOC_PLUGIN']=$triggerDetail->sNamespace;
$oAppDocument1 = new AppDocument();
$oAppDocument1->update($aFields);
$sPathName = PATH_DOCUMENT . $sApplication . PATH_SEP;
$oData['APP_UID'] = $sApplication;
$oData['ATTACHMENT_FOLDER'] = true;
switch($aOD['OUT_DOC_GENERATE']){
case "BOTH":
$documentData = new uploadDocumentData (
$sApplication,
$sUserLogged,
$pathOutput . $sFilename . '.pdf',
$sFilename. '.pdf',
$sDocUID,
$oAppDocument->getDocVersion()
);
$documentData->sFileType = "PDF";
$documentData->bUseOutputFolder = true;
$uploadReturn=$oPluginRegistry->executeTriggers ( PM_UPLOAD_DOCUMENT , $documentData );
if($uploadReturn){//Only delete if the file was saved correctly
unlink ( $pathOutput . $sFilename. '.pdf' );
}
$documentData = new uploadDocumentData (
$sApplication,
$sUserLogged,
$pathOutput . $sFilename . '.doc',
$sFilename. '.doc',
$sDocUID,
$oAppDocument->getDocVersion()
);
$documentData->sFileType = "DOC";
$documentData->bUseOutputFolder = true;
$uploadReturn=$oPluginRegistry->executeTriggers ( PM_UPLOAD_DOCUMENT , $documentData );
if($uploadReturn){//Only delete if the file was saved correctly
unlink ( $pathOutput . $sFilename. '.doc' );
}
break;
case "PDF":
$documentData = new uploadDocumentData (
$sApplication,
$sUserLogged,
$pathOutput . $sFilename . '.pdf',
$sFilename. '.pdf',
$sDocUID,
$oAppDocument->getDocVersion()
);
$documentData->sFileType = "PDF";
$documentData->bUseOutputFolder = true;
$uploadReturn=$oPluginRegistry->executeTriggers ( PM_UPLOAD_DOCUMENT , $documentData );
if($uploadReturn){//Only delete if the file was saved correctly
unlink ( $pathOutput . $sFilename. '.pdf' );
}
break;
case "DOC":
$documentData = new uploadDocumentData (
$sApplication,
$sUserLogged,
$pathOutput . $sFilename . '.doc',
$sFilename. '.doc',
$sDocUID,
$oAppDocument->getDocVersion()
);
$documentData->sFileType = "DOC";
$documentData->bUseOutputFolder = true;
$uploadReturn=$oPluginRegistry->executeTriggers ( PM_UPLOAD_DOCUMENT , $documentData );
if($uploadReturn){//Only delete if the file was saved correctly
unlink ( $pathOutput . $sFilename. '.doc' );
}
break;
}
}
}
/**
* @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, $sUserLogged = null) {
if(!$sUserLogged) {
$sUserLogged = $_SESSION['USER_LOGGED'];
}
G::LoadClass('wsBase');
$ws = new wsBase ();
$result = $ws->derivateCase($sUserLogged, $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 ) {
try {
$x = PMFDerivateCase($caseId, $delIndex);
if($x==0)
G::SendTemporalMessage('ID_NOT_DERIVATED', 'error', 'labels');
} catch (Exception $oException) {
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) {
$iDelegation = intval($iDelegation);
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();
global $oPMScript;
$aRow = $oDataset->getRow();
if ($aRow) {
require_once 'classes/model/Step.php';
$oStep = new Step();
$oTheStep = $oStep->loadByType($aRow['TAS_UID'], $sStepType, $sStepUid);
$bContinue = true;
G::LoadClass('case');
$oCase = new Cases();
$aFields = $oCase->loadCase($sApplicationUID);
if ($oTheStep->getStepCondition() != '') {
G::LoadClass('pmScript');
$pmScript = new PMScript();
$pmScript->setFields($aFields['APP_DATA']);
$pmScript->setScript($oTheStep->getStepCondition());
$bContinue = $pmScript->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;
}
// save data
if (!is_null($oPMScript)) {
$aFields['APP_DATA'] = $oPMScript->aFields;
$oCase->updateCase($sApplicationUID,$aFields);
}
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 PMFGetNextAssignedUser
* @label PMFGet Next Assigned User
*
* @param string(32) | $application | Case ID | Id of the case
* @param string(32) | $task | Task ID | Id of the task
* @return array | $array | List of users | Return a list of users
*
*/
function PMFGetNextAssignedUser ($application, $task) {
require_once 'classes/model/AppDelegation.php';
require_once 'classes/model/Task.php';
require_once 'classes/model/TaskUser.php';
require_once 'classes/model/Users.php';
require_once 'classes/model/Groupwf.php';
require_once 'classes/model/GroupUser.php';
$oTask = new Task();
$TaskFields = $oTask->load ($task);
$typeTask = $TaskFields ['TAS_ASSIGN_TYPE'];
if($typeTask == 'BALANCED')
{
G::LoadClass('derivation');
$oDerivation = new Derivation();
$aDeriv = $oDerivation->prepareInformation(
array( 'USER_UID' => $_SESSION['USER_LOGGED'],
'APP_UID' => $application,
'DEL_INDEX' => $_SESSION['INDEX'])
);
foreach($aDeriv as $derivation){
$aUser = array(
'USR_UID' => $derivation['NEXT_TASK']['USER_ASSIGNED']['USR_UID'],
'USR_USERNAME' => $derivation['NEXT_TASK']['USER_ASSIGNED']['USR_USERNAME'],
'USR_FIRSTNAME'=> $derivation['NEXT_TASK']['USER_ASSIGNED']['USR_FIRSTNAME'],
'USR_LASTNAME' => $derivation['NEXT_TASK']['USER_ASSIGNED']['USR_LASTNAME'],
'USR_EMAIL' => $derivation['NEXT_TASK']['USER_ASSIGNED']['USR_EMAIL']
);
$aUsers[] = $aUser;
}
if(count($aUsers) == 1)
return $aUser;
else
return $aUsers;
} else
{
return false;
}
}
//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;
}
}
Reference in New Issue View Git Blame Copy Permalink