2010-12-02 23:34:41 +00:00
< ? php
/**
* class . derivation . php
2012-10-09 12:40:24 -04:00
*
2011-02-01 12:49:40 +00:00
* @ package workflow . engine . ProcessMaker
2010-12-02 23:34:41 +00:00
*
* ProcessMaker Open Source Edition
2011-02-01 12:49:40 +00:00
* Copyright ( C ) 2004 - 2011 Colosa Inc .
2010-12-02 23:34:41 +00:00
*
* 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
2012-10-09 12:40:24 -04:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
2010-12-02 23:34:41 +00:00
* GNU Affero General Public License for more details .
*
* You should have received a copy of the GNU Affero General Public License
2012-10-09 12:40:24 -04:00
* along with this program . If not , see < http :// www . gnu . org / licenses />.
2010-12-02 23:34:41 +00:00
*
* For more information , contact Colosa Inc , 2566 Le Jeune Rd . ,
* Coral Gables , FL , 33134 , USA , or email info @ colosa . com .
*
*/
2012-10-09 12:40:24 -04:00
require_once ( " classes/model/Task.php " );
require_once ( " classes/model/Process.php " );
require_once ( " classes/model/Step.php " );
require_once ( " classes/model/Application.php " );
require_once ( 'classes/model/Groupwf.php' );
require_once ( " classes/model/GroupUser.php " );
require_once ( " classes/model/AppDelegation.php " );
require_once ( " classes/model/Route.php " );
require_once ( 'classes/model/SubApplication.php' );
require_once ( 'classes/model/SubProcess.php' );
require_once ( " classes/model/Users.php " );
G :: LoadClass ( " plugin " );
2010-12-02 23:34:41 +00:00
/**
* derivation - derivation class
2012-10-09 12:40:24 -04:00
*
2011-02-01 12:49:40 +00:00
* @ package workflow . engine . ProcessMaker
2010-12-02 23:34:41 +00:00
*
*/
class Derivation
{
2012-10-09 12:40:24 -04:00
var $case ;
/**
* prepareInformation
*
* @ param array $aData
* @ return $taskInfo
*/
function prepareInformation ( $aData )
{
$oTask = new Task ();
//SELECT *
//FROM APP_DELEGATION AS A
//LEFT JOIN TASK AS T ON(T.TAS_UID = A.TAS_UID)
//LEFT JOIN ROUTE AS R ON(R.TAS_UID = A.TAS_UID)
//WHERE
//APP_UID = '$aData['APP_UID']'
//AND DEL_INDEX = '$aData['DEL_INDEX']'
$c = new Criteria ( 'workflow' );
$c -> clearSelectColumns ();
$c -> addSelectColumn ( AppDelegationPeer :: TAS_UID );
$c -> addSelectColumn ( RoutePeer :: ROU_CONDITION );
$c -> addSelectColumn ( RoutePeer :: ROU_NEXT_TASK );
$c -> addSelectColumn ( RoutePeer :: ROU_TYPE );
$c -> addJoin ( AppDelegationPeer :: TAS_UID , TaskPeer :: TAS_UID , Criteria :: LEFT_JOIN );
$c -> addJoin ( AppDelegationPeer :: TAS_UID , RoutePeer :: TAS_UID , Criteria :: LEFT_JOIN );
$c -> add ( AppDelegationPeer :: APP_UID , $aData [ 'APP_UID' ] );
$c -> add ( AppDelegationPeer :: DEL_INDEX , $aData [ 'DEL_INDEX' ] );
$c -> addAscendingOrderByColumn ( RoutePeer :: ROU_CASE );
$rs = AppDelegationPeer :: doSelectRs ( $c );
$rs -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
$rs -> next ();
$aDerivation = $rs -> getRow ();
$i = 0 ;
$taskInfo = array ();
$oUser = new Users ();
2013-02-19 11:36:10 -04:00
if ( ! class_exists ( 'Cases' )) {
G :: LoadClass ( 'case' );
}
2012-10-09 12:40:24 -04:00
$this -> case = new Cases ();
// 1. there is no rule
if ( is_null ( $aDerivation [ 'ROU_NEXT_TASK' ] )) {
throw ( new Exception ( G :: LoadTranslation ( 'ID_NO_DERIVATION_RULE' ) ));
}
2010-12-02 23:34:41 +00:00
2012-10-09 12:40:24 -04:00
while ( is_array ( $aDerivation )) {
$oTask = new Task ();
$aDerivation = G :: array_merges ( $aDerivation , $aData );
$bContinue = true ;
//evaluate the condition if there are conditions defined.
if ( isset ( $aDerivation [ 'ROU_CONDITION' ] ) && trim ( $aDerivation [ 'ROU_CONDITION' ] ) != '' && ( $aDerivation [ 'ROU_TYPE' ] != 'SELECT' || $aDerivation [ 'ROU_TYPE' ] == 'PARALLEL-BY-EVALUATION' )) {
$AppFields = $this -> case -> loadCase ( $aData [ 'APP_UID' ] );
G :: LoadClass ( 'pmScript' );
$oPMScript = new PMScript ();
$oPMScript -> setFields ( $AppFields [ 'APP_DATA' ] );
$oPMScript -> setScript ( $aDerivation [ 'ROU_CONDITION' ] );
$bContinue = $oPMScript -> evaluate ();
}
2010-12-02 23:34:41 +00:00
2012-10-09 12:40:24 -04:00
if ( $aDerivation [ 'ROU_TYPE' ] == 'EVALUATE' ) {
if ( count ( $taskInfo ) >= 1 ) {
$bContinue = false ;
}
}
2010-12-02 23:34:41 +00:00
2012-10-09 12:40:24 -04:00
if ( $bContinue ) {
$i ++ ;
$TaskFields = $oTask -> load ( $aDerivation [ 'TAS_UID' ] );
$aDerivation = G :: array_merges ( $aDerivation , $TaskFields );
//2. if next case is an special case
if (( int ) $aDerivation [ 'ROU_NEXT_TASK' ] < 0 ) {
$aDerivation [ 'NEXT_TASK' ][ 'TAS_UID' ] = ( int ) $aDerivation [ 'ROU_NEXT_TASK' ];
$aDerivation [ 'NEXT_TASK' ][ 'TAS_ASSIGN_TYPE' ] = 'nobody' ;
$aDerivation [ 'NEXT_TASK' ][ 'TAS_PRIORITY_VARIABLE' ] = '' ;
$aDerivation [ 'NEXT_TASK' ][ 'TAS_DEF_PROC_CODE' ] = '' ;
$aDerivation [ 'NEXT_TASK' ][ 'TAS_PARENT' ] = '' ;
$aDerivation [ 'NEXT_TASK' ][ 'TAS_TRANSFER_FLY' ] = '' ;
switch ( $aDerivation [ 'ROU_NEXT_TASK' ]) {
case - 1 :
$aDerivation [ 'NEXT_TASK' ][ 'TAS_TITLE' ] = G :: LoadTranslation ( 'ID_END_OF_PROCESS' );
break ;
case - 2 :
$aDerivation [ 'NEXT_TASK' ][ 'TAS_TITLE' ] = G :: LoadTranslation ( 'ID_TAREA_COLGANTE' );
break ;
}
$aDerivation [ 'NEXT_TASK' ][ 'USR_UID' ] = '' ;
2013-01-24 12:54:12 -04:00
$aDerivation [ 'NEXT_TASK' ][ 'USER_ASSIGNED' ] = array ( 'USR_UID' => '' );
2012-10-09 12:40:24 -04:00
} else {
//3. load the task information of normal NEXT_TASK
$aDerivation [ 'NEXT_TASK' ] = $oTask -> load ( $aDerivation [ 'ROU_NEXT_TASK' ] ); //print $aDerivation['ROU_NEXT_TASK']." **** ".$aDerivation['NEXT_TASK']['TAS_TYPE']."<hr>";
if ( $aDerivation [ 'NEXT_TASK' ][ 'TAS_TYPE' ] === 'SUBPROCESS' ) {
$oCriteria = new Criteria ( 'workflow' );
$oCriteria -> add ( SubProcessPeer :: PRO_PARENT , $aDerivation [ 'PRO_UID' ] );
$oCriteria -> add ( SubProcessPeer :: TAS_PARENT , $aDerivation [ 'NEXT_TASK' ][ 'TAS_UID' ] );
$oDataset = SubProcessPeer :: doSelectRS ( $oCriteria );
$oDataset -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
$oDataset -> next ();
$aRow = $oDataset -> getRow ();
$sTaskParent = $aDerivation [ 'NEXT_TASK' ][ 'TAS_UID' ];
$aDerivation [ 'ROU_NEXT_TASK' ] = $aRow [ 'TAS_UID' ]; //print "<hr>Life is just a lonely highway";
$aDerivation [ 'NEXT_TASK' ] = $oTask -> load ( $aDerivation [ 'ROU_NEXT_TASK' ] ); //print "<hr>Life is just a lonely highway";print"<hr>";
$oProcess = new Process ();
$aRow = $oProcess -> load ( $aRow [ 'PRO_UID' ] );
$aDerivation [ 'NEXT_TASK' ][ 'TAS_TITLE' ] .= ' (' . $aRow [ 'PRO_TITLE' ] . ')' ;
$aDerivation [ 'NEXT_TASK' ][ 'TAS_PARENT' ] = $sTaskParent ;
unset ( $oTask , $oProcess , $aRow , $sTaskParent );
} else {
$aDerivation [ 'NEXT_TASK' ][ 'TAS_PARENT' ] = '' ;
}
$aDerivation [ 'NEXT_TASK' ][ 'USER_ASSIGNED' ] = $this -> getNextAssignedUser ( $aDerivation );
}
$taskInfo [ $i ] = $aDerivation ;
}
$rs -> next ();
$aDerivation = $rs -> getRow ();
}
return $taskInfo ;
2010-12-02 23:34:41 +00:00
}
2012-10-09 12:40:24 -04:00
/**
* getRouteCondition
*
* @ param array $aData
* @ return $routeCondition
*/
function getRouteCondition ( $aData )
{
//SELECT *
//FROM APP_DELEGATION AS A
//LEFT JOIN TASK AS T ON(T.TAS_UID = A.TAS_UID)
//LEFT JOIN ROUTE AS R ON(R.TAS_UID = A.TAS_UID)
//WHERE
//APP_UID = '$aData['APP_UID']'
//AND DEL_INDEX = '$aData['DEL_INDEX']'
$c = new Criteria ( 'workflow' );
$c -> clearSelectColumns ();
$c -> addSelectColumn ( AppDelegationPeer :: TAS_UID );
$c -> addSelectColumn ( RoutePeer :: ROU_CONDITION );
$c -> addSelectColumn ( RoutePeer :: ROU_NEXT_TASK );
$c -> addSelectColumn ( RoutePeer :: ROU_TYPE );
$c -> addSelectColumn ( RoutePeer :: ROU_OPTIONAL );
$c -> addJoin ( AppDelegationPeer :: TAS_UID , TaskPeer :: TAS_UID , Criteria :: LEFT_JOIN );
$c -> addJoin ( AppDelegationPeer :: TAS_UID , RoutePeer :: TAS_UID , Criteria :: LEFT_JOIN );
$c -> add ( AppDelegationPeer :: APP_UID , $aData [ 'APP_UID' ] );
$c -> add ( AppDelegationPeer :: DEL_INDEX , $aData [ 'DEL_INDEX' ] );
$c -> addAscendingOrderByColumn ( RoutePeer :: ROU_CASE );
$rs = AppDelegationPeer :: doSelectRs ( $c );
$rs -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
$rs -> next ();
$aDerivation = $rs -> getRow ();
while ( is_array ( $aDerivation )) {
return $aDerivation ;
}
2010-12-02 23:34:41 +00:00
}
2012-10-09 12:40:24 -04:00
function GetAppParentIndex ( $aData )
{
//('SELECT * FROM APP_THREAD WHERE APP_UID='".$aData['APP_UID']."' AND DEL_INDEX = '".$aData['DEL_INDEX']."'");
try {
$aThreads = array ();
$c = new Criteria ();
$c -> addSelectColumn ( AppThreadPeer :: APP_THREAD_PARENT );
$c -> add ( AppThreadPeer :: APP_UID , $aData [ 'APP_UID' ] );
$c -> add ( AppThreadPeer :: DEL_INDEX , $aData [ 'DEL_INDEX' ] );
$rs = AppThreadPeer :: doSelectRs ( $c );
$rs -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
$rs -> next ();
$row = $rs -> getRow ();
while ( is_array ( $row )) {
$aThreads = $row ;
$rs -> next ();
$row = $rs -> getRow ();
}
return $aThreads ;
} catch ( exception $e ) {
throw ( $e );
}
}
2010-12-02 23:34:41 +00:00
2012-10-09 12:40:24 -04:00
/* get all users , from any task , if the task have Groups , the function expand the group
2012-10-22 15:45:47 -04:00
*
* @ param string $sTasUid the task uidUser
* @ return Array $users an array with userID order by USR_UID
*/
2012-10-09 12:40:24 -04:00
function getAllUsersFromAnyTask ( $sTasUid )
{
$users = array ();
$c = new Criteria ( 'workflow' );
$c -> clearSelectColumns ();
$c -> addSelectColumn ( TaskUserPeer :: USR_UID );
$c -> addSelectColumn ( TaskUserPeer :: TU_RELATION );
$c -> add ( TaskUserPeer :: TAS_UID , $sTasUid );
$c -> add ( TaskUserPeer :: TU_TYPE , 1 );
$rs = TaskUserPeer :: DoSelectRs ( $c );
$rs -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
$rs -> next ();
$row = $rs -> getRow ();
while ( is_array ( $row )) {
if ( $row [ 'TU_RELATION' ] == '2' ) {
$cGrp = new Criteria ( 'workflow' );
$cGrp -> add ( GroupwfPeer :: GRP_STATUS , 'ACTIVE' );
$cGrp -> add ( GroupUserPeer :: GRP_UID , $row [ 'USR_UID' ] );
$cGrp -> addJoin ( GroupUserPeer :: GRP_UID , GroupwfPeer :: GRP_UID , Criteria :: LEFT_JOIN );
$cGrp -> addJoin ( GroupUserPeer :: USR_UID , UsersPeer :: USR_UID , Criteria :: LEFT_JOIN );
2012-10-10 17:13:17 -04:00
$cGrp -> add ( UsersPeer :: USR_STATUS , 'INACTIVE' , Criteria :: NOT_EQUAL );
2012-10-09 12:40:24 -04:00
$rsGrp = GroupUserPeer :: DoSelectRs ( $cGrp );
$rsGrp -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
$rsGrp -> next ();
$rowGrp = $rsGrp -> getRow ();
while ( is_array ( $rowGrp )) {
$users [ $rowGrp [ 'USR_UID' ]] = $rowGrp [ 'USR_UID' ];
$rsGrp -> next ();
$rowGrp = $rsGrp -> getRow ();
}
} else {
//filter to users that is in vacation or has an inactive estatus, and others
$oUser = UsersPeer :: retrieveByPK ( $row [ 'USR_UID' ] );
if ( $oUser -> getUsrStatus () == 'ACTIVE' ) {
$users [ $row [ 'USR_UID' ]] = $row [ 'USR_UID' ];
} else {
$userUID = $this -> checkReplacedByUser ( $oUser );
if ( $userUID != '' ) {
$users [ $userUID ] = $userUID ;
}
}
}
$rs -> next ();
$row = $rs -> getRow ();
2010-12-02 23:34:41 +00:00
}
2012-10-09 12:40:24 -04:00
//to do: different types of sort
sort ( $users );
2010-12-02 23:34:41 +00:00
2012-10-09 12:40:24 -04:00
return $users ;
}
2010-12-02 23:34:41 +00:00
2012-10-09 12:40:24 -04:00
/* get an array of users , and returns the same arrays with User ' s fullname and other fields
2012-10-22 15:45:47 -04:00
*
* @ param Array $aUsers the task uidUser
* @ return Array $aUsersData an array with with User ' s fullname
*/
2012-10-09 12:40:24 -04:00
function getUsersFullNameFromArray ( $aUsers )
{
$oUser = new Users ();
$aUsersData = array ();
if ( is_array ( $aUsers )) {
foreach ( $aUsers as $key => $val ) {
2012-10-10 17:13:17 -04:00
// $userFields = $oUser->load( $val );
$userFields = $oUser -> userVacation ( $val );
2012-10-09 12:40:24 -04:00
$auxFields [ 'USR_UID' ] = $userFields [ 'USR_UID' ];
$auxFields [ 'USR_USERNAME' ] = $userFields [ 'USR_USERNAME' ];
$auxFields [ 'USR_FIRSTNAME' ] = $userFields [ 'USR_FIRSTNAME' ];
$auxFields [ 'USR_LASTNAME' ] = $userFields [ 'USR_LASTNAME' ];
$auxFields [ 'USR_FULLNAME' ] = $userFields [ 'USR_LASTNAME' ] . ( $userFields [ 'USR_LASTNAME' ] != '' ? ', ' : '' ) . $userFields [ 'USR_FIRSTNAME' ];
$auxFields [ 'USR_EMAIL' ] = $userFields [ 'USR_EMAIL' ];
$auxFields [ 'USR_STATUS' ] = $userFields [ 'USR_STATUS' ];
$auxFields [ 'USR_COUNTRY' ] = $userFields [ 'USR_COUNTRY' ];
$auxFields [ 'USR_CITY' ] = $userFields [ 'USR_CITY' ];
$auxFields [ 'USR_LOCATION' ] = $userFields [ 'USR_LOCATION' ];
$auxFields [ 'DEP_UID' ] = $userFields [ 'DEP_UID' ];
$auxFields [ 'USR_HIDDEN_FIELD' ] = '' ;
$aUsersData [] = $auxFields ;
}
} else {
$oCriteria = new Criteria ();
$oCriteria -> add ( UsersPeer :: USR_UID , $aUsers );
if ( UsersPeer :: doCount ( $oCriteria ) < 1 ) {
return null ;
}
$userFields = $oUser -> load ( $aUsers );
$auxFields [ 'USR_UID' ] = $userFields [ 'USR_UID' ];
$auxFields [ 'USR_USERNAME' ] = $userFields [ 'USR_USERNAME' ];
$auxFields [ 'USR_FIRSTNAME' ] = $userFields [ 'USR_FIRSTNAME' ];
$auxFields [ 'USR_LASTNAME' ] = $userFields [ 'USR_LASTNAME' ];
$auxFields [ 'USR_FULLNAME' ] = $userFields [ 'USR_LASTNAME' ] . ( $userFields [ 'USR_LASTNAME' ] != '' ? ', ' : '' ) . $userFields [ 'USR_FIRSTNAME' ];
$auxFields [ 'USR_EMAIL' ] = $userFields [ 'USR_EMAIL' ];
$auxFields [ 'USR_STATUS' ] = $userFields [ 'USR_STATUS' ];
$auxFields [ 'USR_COUNTRY' ] = $userFields [ 'USR_COUNTRY' ];
$auxFields [ 'USR_CITY' ] = $userFields [ 'USR_CITY' ];
$auxFields [ 'USR_LOCATION' ] = $userFields [ 'USR_LOCATION' ];
$auxFields [ 'DEP_UID' ] = $userFields [ 'DEP_UID' ];
$aUsersData = $auxFields ;
}
return $aUsersData ;
2010-12-02 23:34:41 +00:00
}
2012-10-09 12:40:24 -04:00
/* get next assigned user
2012-10-22 15:45:47 -04:00
*
* @ param Array $tasInfo
* @ return Array $userFields
*/
2012-10-09 12:40:24 -04:00
function getNextAssignedUser ( $tasInfo )
2010-12-02 23:34:41 +00:00
{
2012-10-09 12:40:24 -04:00
$oUser = new Users ();
$nextAssignedTask = $tasInfo [ 'NEXT_TASK' ];
$lastAssigned = $tasInfo [ 'NEXT_TASK' ][ 'TAS_LAST_ASSIGNED' ];
$sTasUid = $tasInfo [ 'NEXT_TASK' ][ 'TAS_UID' ];
// to do: we can increase the LOCATION by COUNTRY, STATE and LOCATION
/* Verify if the next Task is set with the option "TAS_ASSIGN_LOCATION == TRUE" */
$assignLocation = '' ;
if ( $tasInfo [ 'NEXT_TASK' ][ 'TAS_ASSIGN_LOCATION' ] == 'TRUE' ) {
$oUser -> load ( $tasInfo [ 'USER_UID' ] );
krumo ( $oUser -> getUsrLocation () );
//to do: assign for location
//$assignLocation = " AND USR_LOCATION = " . $oUser->Fields['USR_LOCATION'];
}
/* End - Verify if the next Task is set with the option "TAS_ASSIGN_LOCATION == TRUE" */
$uidUser = '' ;
switch ( $nextAssignedTask [ 'TAS_ASSIGN_TYPE' ]) {
case 'BALANCED' :
$users = $this -> getAllUsersFromAnyTask ( $sTasUid );
if ( is_array ( $users ) && count ( $users ) > 0 ) {
//to do apply any filter like LOCATION assignment
$uidUser = $users [ 0 ];
$i = count ( $users ) - 1 ;
while ( $i > 0 ) {
2012-10-22 15:45:47 -04:00
if ( $lastAssigned < $users [ $i ]) {
2012-10-09 12:40:24 -04:00
$uidUser = $users [ $i ];
2012-10-22 15:45:47 -04:00
}
2012-10-09 12:40:24 -04:00
$i -- ;
}
} else {
throw ( new Exception ( G :: LoadTranslation ( 'ID_NO_USERS' ) ));
}
$userFields = $this -> getUsersFullNameFromArray ( $uidUser );
break ;
case 'STATIC_MI' :
case 'CANCEL_MI' :
case 'MANUAL' :
$users = $this -> getAllUsersFromAnyTask ( $sTasUid );
$userFields = $this -> getUsersFullNameFromArray ( $users );
break ;
case 'EVALUATE' :
$AppFields = $this -> case -> loadCase ( $tasInfo [ 'APP_UID' ] );
$variable = str_replace ( '@@' , '' , $nextAssignedTask [ 'TAS_ASSIGN_VARIABLE' ] );
if ( isset ( $AppFields [ 'APP_DATA' ][ $variable ] )) {
if ( $AppFields [ 'APP_DATA' ][ $variable ] != '' ) {
$value = $this -> checkReplacedByUser ( $AppFields [ 'APP_DATA' ][ $variable ] );
$userFields = $this -> getUsersFullNameFromArray ( $value );
if ( is_null ( $userFields )) {
throw ( new Exception ( " Task doesn't have a valid user in variable $variable . " ));
}
} else {
throw ( new Exception ( " Task doesn't have a valid user in variable $variable . " ));
}
2012-10-22 15:45:47 -04:00
} else {
2012-10-09 12:40:24 -04:00
throw ( new Exception ( " Task doesn't have a valid user in variable $variable or this variable doesn't exist. " ));
2012-10-22 15:45:47 -04:00
}
2012-10-09 12:40:24 -04:00
break ;
case 'REPORT_TO' :
//default error user when the reportsTo is not assigned to that user
//look for USR_REPORTS_TO to this user
$userFields [ 'USR_UID' ] = '' ;
$userFields [ 'USR_FULLNAME' ] = 'Current user does not have a valid Reports To user' ;
$userFields [ 'USR_USERNAME' ] = 'Current user does not have a valid Reports To user' ;
$userFields [ 'USR_FIRSTNAME' ] = '' ;
$userFields [ 'USR_LASTNAME' ] = '' ;
$userFields [ 'USR_EMAIL' ] = '' ;
//get the report_to user & its full info
2013-03-12 10:24:34 -04:00
$useruid = $this -> checkReplacedByUser ( $this -> getDenpendentUser ( $tasInfo [ 'USER_UID' ] ) );
2012-10-09 12:40:24 -04:00
if ( isset ( $useruid ) && $useruid != '' ) {
$userFields = $this -> getUsersFullNameFromArray ( $useruid );
}
// if there is no report_to user info, throw an exception indicating this
if ( ! isset ( $userFields ) || $userFields [ 'USR_UID' ] == '' ) {
throw ( new Exception ( G :: LoadTranslation ( 'ID_MSJ_REPORSTO' ) )); // "The current user does not have a valid Reports To user. Please contact administrator.") ) ;
}
break ;
case 'SELF_SERVICE' :
//look for USR_REPORTS_TO to this user
$userFields [ 'USR_UID' ] = '' ;
$userFields [ 'USR_FULLNAME' ] = '<b>' . G :: LoadTranslation ( 'ID_UNASSIGNED' ) . '</b>' ;
$userFields [ 'USR_USERNAME' ] = '<b>' . G :: LoadTranslation ( 'ID_UNASSIGNED' ) . '</b>' ;
$userFields [ 'USR_FIRSTNAME' ] = '' ;
$userFields [ 'USR_LASTNAME' ] = '' ;
$userFields [ 'USR_EMAIL' ] = '' ;
break ;
default :
throw ( new Exception ( 'Invalid Task Assignment method for Next Task ' ));
}
return $userFields ;
2010-12-02 23:34:41 +00:00
}
2012-10-09 12:40:24 -04:00
/* getDenpendentUser
2012-10-22 15:45:47 -04:00
*
* @ param string $USR_UID
* @ return string $aRow [ 'USR_REPORTS_TO' ]
*/
function getDenpendentUser ( $USR_UID )
{
2012-10-12 14:20:39 -04:00
//Here the uid to next user
2012-10-09 12:40:24 -04:00
$oC = new Criteria ();
2012-10-22 15:45:47 -04:00
$oC -> addSelectColumn ( UsersPeer :: USR_REPORTS_TO );
$oC -> add ( UsersPeer :: USR_UID , $USR_UID );
$oDataset = UsersPeer :: doSelectRS ( $oC );
$oDataset -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
2012-10-09 12:40:24 -04:00
$oDataset -> next ();
$aRow = $oDataset -> getRow ();
2012-10-12 14:20:39 -04:00
return $aRow [ 'USR_REPORTS_TO' ] != '' ? $aRow [ 'USR_REPORTS_TO' ] : $USR_UID ;
2012-10-09 12:40:24 -04:00
}
/* setTasLastAssigned
2012-10-22 15:45:47 -04:00
*
* @ param string $tasUid
* @ param string $usrUid
* @ throws Exception $e
* @ return void
*/
2012-10-09 12:40:24 -04:00
function setTasLastAssigned ( $tasUid , $usrUid )
{
try {
$oTask = TaskPeer :: retrieveByPk ( $tasUid );
$oTask -> setTasLastAssigned ( $usrUid );
$oTask -> save ();
} catch ( Exception $e ) {
throw ( $e );
}
2010-12-02 23:34:41 +00:00
}
2010-12-07 11:49:51 +00:00
2012-10-09 12:40:24 -04:00
/* derivate
2012-10-22 15:45:47 -04:00
*
* @ param array $currentDelegation
* @ param array $nextDelegations
* @ return void
*/
2012-10-09 12:40:24 -04:00
function derivate ( $currentDelegation = array (), $nextDelegations = array ())
{
//define this...
2012-10-22 15:45:47 -04:00
if ( ! defined ( 'TASK_FINISH_PROCESS' )) {
2012-10-09 12:40:24 -04:00
define ( 'TASK_FINISH_PROCESS' , - 1 );
2012-10-22 15:45:47 -04:00
}
if ( ! defined ( 'TASK_FINISH_TASK' )) {
2012-10-09 12:40:24 -04:00
define ( 'TASK_FINISH_TASK' , - 2 );
2012-10-22 15:45:47 -04:00
}
2012-10-09 12:40:24 -04:00
$this -> case = new cases ();
//first, we close the current derivation, then we'll try to derivate to each defined route
$appFields = $this -> case -> loadCase ( $currentDelegation [ 'APP_UID' ], $currentDelegation [ 'DEL_INDEX' ] );
$this -> case -> CloseCurrentDelegation ( $currentDelegation [ 'APP_UID' ], $currentDelegation [ 'DEL_INDEX' ] );
//Count how many tasks should be derivated.
//$countNextTask = count($nextDelegations);
foreach ( $nextDelegations as $nextDel ) {
//subprocesses??
if ( $nextDel [ 'TAS_PARENT' ] != '' ) {
$oCriteria = new Criteria ( 'workflow' );
$oCriteria -> add ( SubProcessPeer :: PRO_PARENT , $appFields [ 'PRO_UID' ] );
$oCriteria -> add ( SubProcessPeer :: TAS_PARENT , $nextDel [ 'TAS_PARENT' ] );
if ( SubProcessPeer :: doCount ( $oCriteria ) > 0 ) {
$oDataset = SubProcessPeer :: doSelectRS ( $oCriteria );
$oDataset -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
$oDataset -> next ();
$aSP = $oDataset -> getRow ();
$aSP [ 'USR_UID' ] = $nextDel [ 'USR_UID' ];
$oTask = new Task ();
$aTask = $oTask -> load ( $nextDel [ 'TAS_PARENT' ] );
$nextDel = array ( 'TAS_UID' => $aTask [ 'TAS_UID' ], 'USR_UID' => $aSP [ 'USR_UID' ], 'TAS_ASSIGN_TYPE' => $aTask [ 'TAS_ASSIGN_TYPE' ], 'TAS_DEF_PROC_CODE' => $aTask [ 'TAS_DEF_PROC_CODE' ], 'DEL_PRIORITY' => 3 , 'TAS_PARENT' => ''
);
} else {
continue ;
}
}
//get TAS_ASSIGN_TYPE for current Delegation
$oTask = new Task ();
$aTask = $oTask -> load ( $currentDelegation [ 'TAS_UID' ] );
$currentDelegation [ 'TAS_ASSIGN_TYPE' ] = $aTask [ 'TAS_ASSIGN_TYPE' ];
$currentDelegation [ 'TAS_MI_COMPLETE_VARIABLE' ] = $aTask [ 'TAS_MI_COMPLETE_VARIABLE' ];
$currentDelegation [ 'TAS_MI_INSTANCE_VARIABLE' ] = $aTask [ 'TAS_MI_INSTANCE_VARIABLE' ];
//get open threads
$openThreads = $this -> case -> GetOpenThreads ( $currentDelegation [ 'APP_UID' ] );
//if we are derivating to finish process but there are no more open thread then we are finishing only the task, we are not finishing the whole process
if (( $nextDel [ 'TAS_UID' ] == TASK_FINISH_PROCESS ) && (( $openThreads + 1 ) > 1 )) {
$nextDel [ 'TAS_UID' ] = TASK_FINISH_TASK ;
}
switch ( $nextDel [ 'TAS_UID' ]) {
case TASK_FINISH_PROCESS :
2012-10-22 15:45:47 -04:00
/*Close all delegations of $currentDelegation['APP_UID'] */
$this -> case -> closeAllDelegations ( $currentDelegation [ 'APP_UID' ] );
2012-10-09 12:40:24 -04:00
$this -> case -> closeAllThreads ( $currentDelegation [ 'APP_UID' ] );
//I think we need to change the APP_STATUS to completed,
break ;
case TASK_FINISH_TASK :
$iAppThreadIndex = $appFields [ 'DEL_THREAD' ];
$this -> case -> closeAppThread ( $currentDelegation [ 'APP_UID' ], $iAppThreadIndex );
break ;
default :
// get all siblingThreads
//if($currentDelegation['TAS_ASSIGN_TYPE'] == 'STATIC_MI')
switch ( $currentDelegation [ 'TAS_ASSIGN_TYPE' ]) {
case 'CANCEL_MI' :
case 'STATIC_MI' :
$siblingThreads = $this -> case -> GetAllOpenDelegation ( $currentDelegation );
$aData = $this -> case -> loadCase ( $currentDelegation [ 'APP_UID' ] );
2012-10-22 15:45:47 -04:00
if ( isset ( $aData [ 'APP_DATA' ][ str_replace ( '@@' , '' , $currentDelegation [ 'TAS_MI_INSTANCE_VARIABLE' ] )] )) {
2012-10-09 12:40:24 -04:00
$sMIinstanceVar = $aData [ 'APP_DATA' ][ str_replace ( '@@' , '' , $currentDelegation [ 'TAS_MI_INSTANCE_VARIABLE' ] )];
2012-10-22 15:45:47 -04:00
} else {
2012-10-09 12:40:24 -04:00
$sMIinstanceVar = $aData [ 'APP_DATA' ][ 'TAS_MI_INSTANCE_VARIABLE' ];
2012-10-22 15:45:47 -04:00
}
2012-10-09 12:40:24 -04:00
2012-10-22 15:45:47 -04:00
if ( isset ( $aData [ 'APP_DATA' ][ str_replace ( '@@' , '' , $currentDelegation [ 'TAS_MI_COMPLETE_VARIABLE' ] )] )) {
2012-10-09 12:40:24 -04:00
$sMIcompleteVar = $aData [ 'APP_DATA' ][ str_replace ( '@@' , '' , $currentDelegation [ 'TAS_MI_COMPLETE_VARIABLE' ] )];
2012-10-22 15:45:47 -04:00
} else {
2012-10-09 12:40:24 -04:00
$sMIcompleteVar = $aData [ 'APP_DATA' ][ 'TAS_MI_COMPLETE_VARIABLE' ];
2012-10-22 15:45:47 -04:00
}
2012-10-09 12:40:24 -04:00
$discriminateThread = $sMIinstanceVar - $sMIcompleteVar ;
// -1 because One App Delegation is closed by above Code
2012-10-22 15:45:47 -04:00
if ( $discriminateThread == count ( $siblingThreads )) {
2012-10-09 12:40:24 -04:00
$canDerivate = true ;
2012-10-22 15:45:47 -04:00
} else {
2012-10-09 12:40:24 -04:00
$canDerivate = false ;
2012-10-22 15:45:47 -04:00
}
2012-10-09 12:40:24 -04:00
break ;
default :
if ( $currentDelegation [ 'ROU_TYPE' ] == 'SEC-JOIN' ) {
$siblingThreads = $this -> case -> getOpenSiblingThreads ( $nextDel [ 'TAS_UID' ], $currentDelegation [ 'APP_UID' ], $currentDelegation [ 'DEL_INDEX' ], $currentDelegation [ 'TAS_UID' ], $currentDelegation [ 'ROU_TYPE' ] );
$canDerivate = count ( $siblingThreads ) == 0 ;
2012-10-22 15:45:47 -04:00
} elseif ( $currentDelegation [ 'ROU_TYPE' ] == 'DISCRIMINATOR' ) {
2012-10-09 12:40:24 -04:00
//First get the total threads of Next Task where route type='Discriminator'
$siblingThreads = $this -> case -> getOpenSiblingThreads ( $nextDel [ 'TAS_UID' ], $currentDelegation [ 'APP_UID' ], $currentDelegation [ 'DEL_INDEX' ], $currentDelegation [ 'TAS_UID' ], $currentDelegation [ 'ROU_TYPE' ] );
$siblingThreadsCount = count ( $siblingThreads );
$discriminateThread = $currentDelegation [ 'ROU_CONDITION' ];
//$checkThread = count($totalThreads) - $cond;
2012-10-22 15:45:47 -04:00
if ( $discriminateThread == $siblingThreadsCount ) {
2012-10-09 12:40:24 -04:00
$canDerivate = true ;
2012-10-22 15:45:47 -04:00
} else {
2012-10-09 12:40:24 -04:00
$canDerivate = false ;
2012-10-22 15:45:47 -04:00
}
2012-10-09 12:40:24 -04:00
} else {
$canDerivate = true ;
}
} //end switch
if ( $canDerivate ) {
$aSP = isset ( $aSP ) ? $aSP : null ;
$iNewDelIndex = $this -> doDerivation ( $currentDelegation , $nextDel , $appFields , $aSP );
2012-10-22 15:45:47 -04:00
} else {
//when the task doesnt generate a new AppDelegation
2012-10-09 12:40:24 -04:00
$iAppThreadIndex = $appFields [ 'DEL_THREAD' ];
switch ( $currentDelegation [ 'ROU_TYPE' ]) {
case 'DISCRIMINATOR' :
case 'SEC-JOIN' :
$this -> case -> closeAppThread ( $currentDelegation [ 'APP_UID' ], $iAppThreadIndex );
break ;
default :
2012-10-22 15:45:47 -04:00
if ( $currentDelegation [ 'TAS_ASSIGN_TYPE' ] == 'STATIC_MI' || $currentDelegation [ 'TAS_ASSIGN_TYPE' ] == 'CANCEL_MI' ) {
2012-10-09 12:40:24 -04:00
$this -> case -> closeAppThread ( $currentDelegation [ 'APP_UID' ], $iAppThreadIndex );
2012-10-22 15:45:47 -04:00
}
2012-10-09 12:40:24 -04:00
} //switch
}
}
//SETS THE APP_PROC_CODE
//if (isset($nextDel['TAS_DEF_PROC_CODE']))
//$appFields['APP_PROC_CODE'] = $nextDel['TAS_DEF_PROC_CODE'];
unset ( $aSP );
} //end foreach
/* Start Block : UPDATES APPLICATION */
//Set THE APP_STATUS
$appFields [ 'APP_STATUS' ] = $currentDelegation [ 'APP_STATUS' ];
/* Start Block : Count the open threads of $currentDelegation['APP_UID'] */
$openThreads = $this -> case -> GetOpenThreads ( $currentDelegation [ 'APP_UID' ] );
///////
$sw = 0 ;
if ( $openThreads == 0 ) {
//Close case
$appFields [ " APP_STATUS " ] = " COMPLETED " ;
$appFields [ " APP_FINISH_DATE " ] = " now " ;
$this -> verifyIsCaseChild ( $currentDelegation [ " APP_UID " ] );
$sw = 1 ;
2010-12-02 23:34:41 +00:00
}
2012-10-09 12:40:24 -04:00
if ( isset ( $iNewDelIndex )) {
$appFields [ " DEL_INDEX " ] = $iNewDelIndex ;
$appFields [ " TAS_UID " ] = $nextDel [ " TAS_UID " ];
$sw = 1 ;
2010-12-02 23:34:41 +00:00
}
2012-10-09 12:40:24 -04:00
if ( $sw == 1 ) {
//Start Block : UPDATES APPLICATION
$this -> case -> updateCase ( $currentDelegation [ " APP_UID " ], $appFields );
//End Block : UPDATES APPLICATION
}
}
function doDerivation ( $currentDelegation , $nextDel , $appFields , $aSP = null )
{
$iAppThreadIndex = $appFields [ 'DEL_THREAD' ];
$delType = 'NORMAL' ;
if ( is_numeric ( $nextDel [ 'DEL_PRIORITY' ] )) {
$nextDel [ 'DEL_PRIORITY' ] = ( isset ( $nextDel [ 'DEL_PRIORITY' ] ) ? ( $nextDel [ 'DEL_PRIORITY' ] >= 1 && $nextDel [ 'DEL_PRIORITY' ] <= 5 ? $nextDel [ 'DEL_PRIORITY' ] : '3' ) : '3' );
} else {
$nextDel [ 'DEL_PRIORITY' ] = 3 ;
}
switch ( $nextDel [ 'TAS_ASSIGN_TYPE' ]) {
2010-12-02 23:34:41 +00:00
case 'CANCEL_MI' :
case 'STATIC_MI' :
2012-10-09 12:40:24 -04:00
// Create new delegation depending on the no of users in the group
$iNewAppThreadIndex = $appFields [ 'DEL_THREAD' ];
$this -> case -> closeAppThread ( $currentDelegation [ 'APP_UID' ], $iAppThreadIndex );
2011-10-24 08:48:59 -04:00
2012-10-09 12:40:24 -04:00
foreach ( $nextDel [ 'NEXT_TASK' ][ 'USER_ASSIGNED' ] as $key => $aValue ) {
//Incrementing the Del_thread First so that new delegation has new del_thread
$iNewAppThreadIndex += 1 ;
//Creating new delegation according to users in group
$iMIDelIndex = $this -> case -> newAppDelegation ( $appFields [ 'PRO_UID' ], $currentDelegation [ 'APP_UID' ], $nextDel [ 'TAS_UID' ], ( isset ( $aValue [ 'USR_UID' ] ) ? $aValue [ 'USR_UID' ] : '' ), $currentDelegation [ 'DEL_INDEX' ], $nextDel [ 'DEL_PRIORITY' ], $delType , $iNewAppThreadIndex , $nextDel );
2011-10-24 08:48:59 -04:00
2012-10-09 12:40:24 -04:00
$iNewThreadIndex = $this -> case -> newAppThread ( $currentDelegation [ 'APP_UID' ], $iMIDelIndex , $iAppThreadIndex );
2012-08-16 11:44:17 -04:00
2012-10-09 12:40:24 -04:00
//Setting the del Index for Updating the AppThread delIndex
2012-10-22 15:45:47 -04:00
if ( $key == 0 ) {
2012-10-09 12:40:24 -04:00
$iNewDelIndex = $iMIDelIndex - 1 ;
2012-10-22 15:45:47 -04:00
}
2012-10-09 12:40:24 -04:00
} //end foreach
break ;
case 'BALANCED' :
$this -> setTasLastAssigned ( $nextDel [ 'TAS_UID' ], $nextDel [ 'USR_UID' ] );
2012-10-22 15:45:47 -04:00
//No Break, need no execute the default ones....
2011-10-24 08:48:59 -04:00
default :
2012-10-09 12:40:24 -04:00
// Create new delegation
$iNewDelIndex = $this -> case -> newAppDelegation ( $appFields [ 'PRO_UID' ], $currentDelegation [ 'APP_UID' ], $nextDel [ 'TAS_UID' ], ( isset ( $nextDel [ 'USR_UID' ] ) ? $nextDel [ 'USR_UID' ] : '' ), $currentDelegation [ 'DEL_INDEX' ], $nextDel [ 'DEL_PRIORITY' ], $delType , $iAppThreadIndex , $nextDel );
break ;
}
2012-08-16 11:44:17 -04:00
2012-10-09 12:40:24 -04:00
$iAppThreadIndex = $appFields [ 'DEL_THREAD' ];
2012-08-16 11:44:17 -04:00
2012-10-09 12:40:24 -04:00
switch ( $currentDelegation [ 'ROU_TYPE' ]) {
case 'PARALLEL' :
case 'PARALLEL-BY-EVALUATION' :
$this -> case -> closeAppThread ( $currentDelegation [ 'APP_UID' ], $iAppThreadIndex );
$iNewThreadIndex = $this -> case -> newAppThread ( $currentDelegation [ 'APP_UID' ], $iNewDelIndex , $iAppThreadIndex );
$this -> case -> updateAppDelegation ( $currentDelegation [ 'APP_UID' ], $iNewDelIndex , $iNewThreadIndex );
//print " this->case->updateAppDelegation ( " . $currentDelegation['APP_UID'] .", " . $iNewDelIndex ." , " . $iNewThreadIndex . " )<br>";
break ;
case 'DISCRIMINATOR' :
if ( $currentDelegation [ 'ROU_OPTIONAL' ] == 'TRUE' ) {
$this -> case -> discriminateCases ( $currentDelegation );
} //No Break, executing Default Condition
default :
switch ( $currentDelegation [ 'TAS_ASSIGN_TYPE' ]) {
case 'CANCEL_MI' :
$this -> case -> discriminateCases ( $currentDelegation );
} //No Break, executing updateAppThread
$this -> case -> updateAppThread ( $currentDelegation [ 'APP_UID' ], $iAppThreadIndex , $iNewDelIndex );
} //en switch
//if there are subprocess to create
if ( isset ( $aSP )) {
//Create the new case in the sub-process
// set the initial date to null the time its created
$aNewCase = $this -> case -> startCase ( $aSP [ 'TAS_UID' ], $aSP [ 'USR_UID' ], true );
//Copy case variables to sub-process case
$aFields = unserialize ( $aSP [ 'SP_VARIABLES_OUT' ] );
$aNewFields = array ();
$aOldFields = $this -> case -> loadCase ( $aNewCase [ 'APPLICATION' ] );
foreach ( $aFields as $sOriginField => $sTargetField ) {
$sOriginField = str_replace ( '@' , '' , $sOriginField );
$sOriginField = str_replace ( '#' , '' , $sOriginField );
$sTargetField = str_replace ( '@' , '' , $sTargetField );
$sTargetField = str_replace ( '#' , '' , $sTargetField );
$aNewFields [ $sTargetField ] = isset ( $appFields [ 'APP_DATA' ][ $sOriginField ] ) ? $appFields [ 'APP_DATA' ][ $sOriginField ] : '' ;
}
2012-08-16 11:44:17 -04:00
2012-10-09 12:40:24 -04:00
$aOldFields [ 'APP_DATA' ] = array_merge ( $aOldFields [ 'APP_DATA' ], $aNewFields );
$aOldFields [ 'APP_STATUS' ] = 'TO_DO' ;
2011-10-24 08:48:59 -04:00
2012-10-09 12:40:24 -04:00
$this -> case -> updateCase ( $aNewCase [ 'APPLICATION' ], $aOldFields );
//Create a registry in SUB_APPLICATION table
$aSubApplication = array ( 'APP_UID' => $aNewCase [ 'APPLICATION' ], 'APP_PARENT' => $currentDelegation [ 'APP_UID' ], 'DEL_INDEX_PARENT' => $iNewDelIndex , 'DEL_THREAD_PARENT' => $iAppThreadIndex , 'SA_STATUS' => 'ACTIVE' , 'SA_VALUES_OUT' => serialize ( $aNewFields ), 'SA_INIT_DATE' => date ( 'Y-m-d H:i:s' )
);
2011-10-24 08:48:59 -04:00
2012-10-09 12:40:24 -04:00
if ( $aSP [ 'SP_SYNCHRONOUS' ] == 0 ) {
$aSubApplication [ 'SA_STATUS' ] = 'FINISHED' ;
$aSubApplication [ 'SA_FINISH_DATE' ] = $aSubApplication [ 'SA_INIT_DATE' ];
}
2011-10-24 08:48:59 -04:00
2012-10-09 12:40:24 -04:00
$oSubApplication = new SubApplication ();
$oSubApplication -> create ( $aSubApplication );
//Update the AppDelegation to execute the update trigger
$AppDelegation = AppDelegationPeer :: retrieveByPK ( $aNewCase [ 'APPLICATION' ], $aNewCase [ 'INDEX' ] );
// note added by krlos pacha carlos[at]colosa[dot]com
// the following line of code was commented because it is related to the 6878 bug
//$AppDelegation->setDelInitDate("+1 second");
$AppDelegation -> save ();
//If not is SYNCHRONOUS derivate one more time
if ( $aSP [ 'SP_SYNCHRONOUS' ] == 0 ) {
$this -> case -> setDelInitDate ( $currentDelegation [ 'APP_UID' ], $iNewDelIndex );
2013-01-24 12:54:12 -04:00
$aDeriveTasks = $this -> prepareInformation ( array ( 'USER_UID' => - 1 , 'APP_UID' => $currentDelegation [ 'APP_UID' ], 'DEL_INDEX' => $iNewDelIndex
2012-10-09 12:40:24 -04:00
) );
if ( isset ( $aDeriveTasks [ 1 ] )) {
if ( $aDeriveTasks [ 1 ][ 'ROU_TYPE' ] != 'SELECT' ) {
$nextDelegations2 = array ();
foreach ( $aDeriveTasks as $aDeriveTask ) {
$nextDelegations2 [] = array ( 'TAS_UID' => $aDeriveTask [ 'NEXT_TASK' ][ 'TAS_UID' ], 'USR_UID' => $aDeriveTask [ 'NEXT_TASK' ][ 'USER_ASSIGNED' ][ 'USR_UID' ], 'TAS_ASSIGN_TYPE' => $aDeriveTask [ 'NEXT_TASK' ][ 'TAS_ASSIGN_TYPE' ], 'TAS_DEF_PROC_CODE' => $aDeriveTask [ 'NEXT_TASK' ][ 'TAS_DEF_PROC_CODE' ], 'DEL_PRIORITY' => 3 , 'TAS_PARENT' => $aDeriveTask [ 'NEXT_TASK' ][ 'TAS_PARENT' ]
);
}
$currentDelegation2 = array ( 'APP_UID' => $currentDelegation [ 'APP_UID' ], 'DEL_INDEX' => $iNewDelIndex , 'APP_STATUS' => 'TO_DO' , 'TAS_UID' => $currentDelegation [ 'TAS_UID' ], 'ROU_TYPE' => $aDeriveTasks [ 1 ][ 'ROU_TYPE' ]
);
$this -> derivate ( $currentDelegation2 , $nextDelegations2 );
}
}
2011-10-24 08:48:59 -04:00
}
2012-10-09 12:40:24 -04:00
} //end switch
return $iNewDelIndex ;
}
2011-10-24 08:48:59 -04:00
2012-10-09 12:40:24 -04:00
/* verifyIsCaseChild
2012-10-22 15:45:47 -04:00
*
* @ param string $sApplicationUID
* @ return void
*/
2012-10-09 12:40:24 -04:00
function verifyIsCaseChild ( $sApplicationUID )
{
//Obtain the related row in the table SUB_APPLICATION
$oCriteria = new Criteria ( 'workflow' );
$oCriteria -> add ( SubApplicationPeer :: APP_UID , $sApplicationUID );
$oDataset = SubApplicationPeer :: doSelectRS ( $oCriteria );
$oDataset -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
$oDataset -> next ();
$aSA = $oDataset -> getRow ();
if ( $aSA ) {
//Obtain the related row in the table SUB_PROCESS
$oCase = new Cases ();
$aParentCase = $oCase -> loadCase ( $aSA [ 'APP_PARENT' ], $aSA [ 'DEL_INDEX_PARENT' ] );
$oCriteria = new Criteria ( 'workflow' );
$oCriteria -> add ( SubProcessPeer :: PRO_PARENT , $aParentCase [ 'PRO_UID' ] );
$oCriteria -> add ( SubProcessPeer :: TAS_PARENT , $aParentCase [ 'TAS_UID' ] );
$oDataset = SubProcessPeer :: doSelectRS ( $oCriteria );
$oDataset -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
$oDataset -> next ();
$aSP = $oDataset -> getRow ();
if ( $aSP [ 'SP_SYNCHRONOUS' ] == 1 ) {
$appFields = $oCase -> loadCase ( $sApplicationUID );
//Copy case variables to parent case
$aFields = unserialize ( $aSP [ 'SP_VARIABLES_IN' ] );
$aNewFields = array ();
foreach ( $aFields as $sOriginField => $sTargetField ) {
$sOriginField = str_replace ( '@' , '' , $sOriginField );
$sOriginField = str_replace ( '#' , '' , $sOriginField );
$sTargetField = str_replace ( '@' , '' , $sTargetField );
$sTargetField = str_replace ( '#' , '' , $sTargetField );
$aNewFields [ $sTargetField ] = isset ( $appFields [ 'APP_DATA' ][ $sOriginField ] ) ? $appFields [ 'APP_DATA' ][ $sOriginField ] : '' ;
}
$aParentCase [ 'APP_DATA' ] = array_merge ( $aParentCase [ 'APP_DATA' ], $aNewFields );
$oCase -> updateCase ( $aSA [ 'APP_PARENT' ], $aParentCase );
//Update table SUB_APPLICATION
$oSubApplication = new SubApplication ();
$oSubApplication -> update ( array ( 'APP_UID' => $sApplicationUID , 'APP_PARENT' => $aSA [ 'APP_PARENT' ], 'DEL_INDEX_PARENT' => $aSA [ 'DEL_INDEX_PARENT' ], 'DEL_THREAD_PARENT' => $aSA [ 'DEL_THREAD_PARENT' ], 'SA_STATUS' => 'FINISHED' , 'SA_VALUES_IN' => serialize ( $aNewFields ), 'SA_FINISH_DATE' => date ( 'Y-m-d H:i:s' )
) );
//Derive the parent case
$aDeriveTasks = $this -> prepareInformation ( array ( 'USER_UID' => - 1 , 'APP_UID' => $aSA [ 'APP_PARENT' ], 'DEL_INDEX' => $aSA [ 'DEL_INDEX_PARENT' ]
) );
if ( isset ( $aDeriveTasks [ 1 ] )) {
if ( $aDeriveTasks [ 1 ][ 'ROU_TYPE' ] != 'SELECT' ) {
$nextDelegations2 = array ();
foreach ( $aDeriveTasks as $aDeriveTask ) {
if ( ! isset ( $aDeriveTask [ 'NEXT_TASK' ][ 'USER_ASSIGNED' ][ 'USR_UID' ] )) {
$selectedUser = $aDeriveTask [ 'NEXT_TASK' ][ 'USER_ASSIGNED' ][ 0 ];
unset ( $aDeriveTask [ 'NEXT_TASK' ][ 'USER_ASSIGNED' ] );
$aDeriveTask [ 'NEXT_TASK' ][ 'USER_ASSIGNED' ] = $selectedUser ;
$myLabels = array ( $aDeriveTask [ 'NEXT_TASK' ][ 'TAS_TITLE' ], $aParentCase [ 'APP_NUMBER' ], $selectedUser [ 'USR_USERNAME' ], $selectedUser [ 'USR_FIRSTNAME' ], $selectedUser [ 'USR_LASTNAME' ]
);
G :: SendTemporalMessage ( 'ID_TASK_WAS_ASSIGNED_TO_USER' , 'warning' , 'labels' , 10 , null , $myLabels );
}
$nextDelegations2 [] = array ( 'TAS_UID' => $aDeriveTask [ 'NEXT_TASK' ][ 'TAS_UID' ], 'USR_UID' => $aDeriveTask [ 'NEXT_TASK' ][ 'USER_ASSIGNED' ][ 'USR_UID' ], 'TAS_ASSIGN_TYPE' => $aDeriveTask [ 'NEXT_TASK' ][ 'TAS_ASSIGN_TYPE' ], 'TAS_DEF_PROC_CODE' => $aDeriveTask [ 'NEXT_TASK' ][ 'TAS_DEF_PROC_CODE' ], 'DEL_PRIORITY' => 3 , 'TAS_PARENT' => $aDeriveTask [ 'NEXT_TASK' ][ 'TAS_PARENT' ]
);
}
$currentDelegation2 = array ( 'APP_UID' => $aSA [ 'APP_PARENT' ], 'DEL_INDEX' => $aSA [ 'DEL_INDEX_PARENT' ], 'APP_STATUS' => 'TO_DO' , 'TAS_UID' => $aParentCase [ 'TAS_UID' ], 'ROU_TYPE' => $aDeriveTasks [ 1 ][ 'ROU_TYPE' ]
);
$this -> derivate ( $currentDelegation2 , $nextDelegations2 );
}
}
2010-12-02 23:34:41 +00:00
}
}
}
2012-10-09 12:40:24 -04:00
/* getDerivatedCases
2012-10-22 15:45:47 -04:00
* get all derivated cases and subcases from any task ,
* this function is useful to know who users have been assigned and what task they do .
*
* @ param string $sParentUid
* @ param string $sDelIndexParent
* @ return array $derivation
*
*/
2012-10-09 12:40:24 -04:00
function getDerivatedCases ( $sParentUid , $sDelIndexParent )
{
$oCriteria = new Criteria ( 'workflow' );
$cases = array ();
$derivation = array ();
//get the child delegations , of parent delIndex
$children = array ();
$oCriteria -> clearSelectColumns ();
$oCriteria -> addSelectColumn ( AppDelegationPeer :: DEL_INDEX );
$oCriteria -> add ( AppDelegationPeer :: APP_UID , $sParentUid );
$oCriteria -> add ( AppDelegationPeer :: DEL_PREVIOUS , $sDelIndexParent );
$oDataset = AppDelegationPeer :: doSelectRS ( $oCriteria );
$oDataset -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
2010-12-02 23:34:41 +00:00
$oDataset -> next ();
$aRow = $oDataset -> getRow ();
2012-10-09 12:40:24 -04:00
while ( is_array ( $aRow )) {
$children [] = $aRow [ 'DEL_INDEX' ];
$oDataset -> next ();
$aRow = $oDataset -> getRow ();
}
//foreach child , get the info of their derivations and subprocesses
foreach ( $children as $keyChild => $child ) {
$oCriteria = new Criteria ( 'workflow' );
$oCriteria -> clearSelectColumns ();
$oCriteria -> addSelectColumn ( SubApplicationPeer :: APP_UID );
$oCriteria -> addSelectColumn ( AppDelegationPeer :: APP_UID );
$oCriteria -> addSelectColumn ( AppDelegationPeer :: DEL_INDEX );
$oCriteria -> addSelectColumn ( AppDelegationPeer :: PRO_UID );
$oCriteria -> addSelectColumn ( AppDelegationPeer :: TAS_UID );
$oCriteria -> addSelectColumn ( AppDelegationPeer :: USR_UID );
$oCriteria -> addSelectColumn ( UsersPeer :: USR_USERNAME );
$oCriteria -> addSelectColumn ( UsersPeer :: USR_FIRSTNAME );
$oCriteria -> addSelectColumn ( UsersPeer :: USR_LASTNAME );
$oCriteria -> add ( SubApplicationPeer :: APP_PARENT , $sParentUid );
$oCriteria -> add ( SubApplicationPeer :: DEL_INDEX_PARENT , $child );
$oCriteria -> addJoin ( SubApplicationPeer :: APP_UID , AppDelegationPeer :: APP_UID );
$oCriteria -> addJoin ( AppDelegationPeer :: USR_UID , UsersPeer :: USR_UID );
$oDataset = SubApplicationPeer :: doSelectRS ( $oCriteria );
$oDataset -> setFetchmode ( ResultSet :: FETCHMODE_ASSOC );
$oDataset -> next ();
$aRow = $oDataset -> getRow ();
while ( is_array ( $aRow )) {
$oProcess = new Process ();
$proFields = $oProcess -> load ( $aRow [ 'PRO_UID' ] );
$oCase = new Application ();
$appFields = $oCase -> load ( $aRow [ 'APP_UID' ] );
$oTask = new Task ();
$tasFields = $oTask -> load ( $aRow [ 'TAS_UID' ] );
$derivation [] = array ( 'processId' => $aRow [ 'PRO_UID' ], 'processTitle' => $proFields [ 'PRO_TITLE' ], 'caseId' => $aRow [ 'APP_UID' ], 'caseNumber' => $appFields [ 'APP_NUMBER' ], 'taskId' => $aRow [ 'TAS_UID' ], 'taskTitle' => $tasFields [ 'TAS_TITLE' ], 'userId' => $aRow [ 'USR_UID' ], 'userName' => $aRow [ 'USR_USERNAME' ], 'userFullname' => $aRow [ 'USR_FIRSTNAME' ] . ' ' . $aRow [ 'USR_LASTNAME' ]
);
2010-12-02 23:34:41 +00:00
2012-10-09 12:40:24 -04:00
$oDataset -> next ();
$aRow = $oDataset -> getRow ();
}
}
return $derivation ;
}
2010-12-02 23:34:41 +00:00
2012-10-09 12:40:24 -04:00
function getGrpUser ( $aData )
{
G :: LoadClass ( 'groups' );
G :: LoadClass ( 'tasks' );
require_once 'classes/model/Content.php' ;
$oTasks = new Tasks ();
$oGroups = new Groups ();
$oContent = new Content ();
$aGroup = array ();
$aUsers = array ();
$aGroup = $oTasks -> getGroupsOfTask ( $aData [ 'ROU_NEXT_TASK' ], 1 );
$aGrpUid = $aGroup [ 0 ][ 'GRP_UID' ];
$sGrpName = $oContent -> load ( 'GRP_TITLE' , '' , $aGrpUid , 'en' );
$aGrp [ 'GRP_NAME' ] = $sGrpName ;
$aGrp [ 'GRP_UID' ] = $aGrpUid ;
$aUsers = $oGroups -> getUsersOfGroup ( $aGroup [ 0 ][ 'GRP_UID' ] );
foreach ( $aUsers as $aKey => $userid ) {
2010-12-02 23:34:41 +00:00
$aData [ $aKey ] = $userid ;
2012-10-09 12:40:24 -04:00
}
return $aGrp ;
}
function checkReplacedByUser ( $user )
{
if ( is_string ( $user )) {
$userInstance = UsersPeer :: retrieveByPK ( $user );
} else {
$userInstance = $user ;
}
if ( ! is_object ( $userInstance )) {
throw new Exception ( " The user with the UID ' $user ' doesn't exist. " );
}
if ( $userInstance -> getUsrStatus () == 'ACTIVE' ) {
return $userInstance -> getUsrUid ();
} else {
$userReplace = trim ( $userInstance -> getUsrReplacedBy () );
if ( $userReplace != '' ) {
return $this -> checkReplacedByUser ( UsersPeer :: retrieveByPK ( $userReplace ) );
} else {
return '' ;
}
}
}
2012-10-22 15:45:47 -04:00
}
2012-08-16 11:44:17 -04:00
