1774 lines
87 KiB
PHP
Executable File
1774 lines
87 KiB
PHP
Executable File
<?php
|
|
/**
|
|
* class.derivation.php
|
|
*
|
|
* @package workflow.engine.ProcessMaker
|
|
*
|
|
* ProcessMaker Open Source Edition
|
|
* Copyright (C) 2004 - 2011 Colosa Inc.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* For more information, contact Colosa Inc, 2566 Le Jeune Rd.,
|
|
* Coral Gables, FL, 33134, USA, or email info@colosa.com.
|
|
*
|
|
*/
|
|
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" );
|
|
|
|
/**
|
|
* derivation - derivation class
|
|
*
|
|
* @package workflow.engine.ProcessMaker
|
|
*
|
|
*/
|
|
|
|
class Derivation
|
|
{
|
|
var $case;
|
|
protected $flagControl;
|
|
protected $flagControlMulInstance;
|
|
|
|
/**
|
|
* prepareInformationTask
|
|
*
|
|
* @param array $arrayTaskData Task data (derivation)
|
|
*
|
|
* @return array Return array
|
|
*/
|
|
private function prepareInformationTask(array $arrayTaskData)
|
|
{
|
|
try {
|
|
$task = new Task();
|
|
|
|
$arrayTaskData = G::array_merges($arrayTaskData, $task->load($arrayTaskData["TAS_UID"]));
|
|
|
|
//2. If next case is an special case
|
|
if ((int)($arrayTaskData["ROU_NEXT_TASK"]) < 0) {
|
|
$arrayTaskData["NEXT_TASK"]["TAS_UID"] = (int)($arrayTaskData["ROU_NEXT_TASK"]);
|
|
$arrayTaskData["NEXT_TASK"]["TAS_ASSIGN_TYPE"] = "nobody";
|
|
$arrayTaskData["NEXT_TASK"]["TAS_PRIORITY_VARIABLE"] = "";
|
|
$arrayTaskData["NEXT_TASK"]["TAS_DEF_PROC_CODE"] = "";
|
|
$arrayTaskData["NEXT_TASK"]["TAS_PARENT"] = "";
|
|
$arrayTaskData["NEXT_TASK"]["TAS_TRANSFER_FLY"] = "";
|
|
|
|
switch ($arrayTaskData["ROU_NEXT_TASK"]) {
|
|
case -1:
|
|
$arrayTaskData["NEXT_TASK"]["TAS_TITLE"] = G::LoadTranslation("ID_END_OF_PROCESS");
|
|
break;
|
|
case -2:
|
|
$arrayTaskData["NEXT_TASK"]["TAS_TITLE"] = G::LoadTranslation("ID_TAREA_COLGANTE");
|
|
break;
|
|
}
|
|
|
|
$arrayTaskData["NEXT_TASK"]["USR_UID"] = "";
|
|
$arrayTaskData["NEXT_TASK"]["USER_ASSIGNED"] = array("USR_UID" => "", "USR_USERNAME" => "");
|
|
} else {
|
|
//3. Load the task information of normal NEXT_TASK
|
|
$arrayTaskData["NEXT_TASK"] = $task->load($arrayTaskData["ROU_NEXT_TASK"]); //print $arrayTaskData["ROU_NEXT_TASK"]." **** ".$arrayTaskData["NEXT_TASK"]["TAS_TYPE"]."<hr>";
|
|
|
|
if ($arrayTaskData["NEXT_TASK"]["TAS_TYPE"] == "SUBPROCESS") {
|
|
$taskParent = $arrayTaskData["NEXT_TASK"]["TAS_UID"];
|
|
|
|
$criteria = new Criteria("workflow");
|
|
$criteria->add(SubProcessPeer::PRO_PARENT, $arrayTaskData["PRO_UID"]);
|
|
$criteria->add(SubProcessPeer::TAS_PARENT, $arrayTaskData["NEXT_TASK"]["TAS_UID"]);
|
|
$rsCriteria = SubProcessPeer::doSelectRS($criteria);
|
|
$rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$rsCriteria->next();
|
|
$row = $rsCriteria->getRow();
|
|
|
|
$arrayTaskData["ROU_NEXT_TASK"] = $row["TAS_UID"]; //print "<hr>Life is just a lonely highway";
|
|
$arrayTaskData["NEXT_TASK"] = $task->load($arrayTaskData["ROU_NEXT_TASK"]); //print "<hr>Life is just a lonely highway";print"<hr>";
|
|
|
|
$process = new Process();
|
|
$row = $process->load($row["PRO_UID"]);
|
|
|
|
$arrayTaskData["NEXT_TASK"]["TAS_TITLE"] .= " (" . $row["PRO_TITLE"] . ")";
|
|
$arrayTaskData["NEXT_TASK"]["TAS_PARENT"] = $taskParent;
|
|
|
|
//unset($task, $process, $row, $taskParent);
|
|
} else {
|
|
$arrayTaskData["NEXT_TASK"]["TAS_PARENT"] = "";
|
|
}
|
|
|
|
$regexpTaskTypeToExclude = "GATEWAYTOGATEWAY|END-MESSAGE-EVENT|SCRIPT-TASK|INTERMEDIATE-CATCH-TIMER-EVENT|END-EMAIL-EVENT";
|
|
|
|
$arrayTaskData["NEXT_TASK"]["USER_ASSIGNED"] = (!preg_match("/^(?:" . $regexpTaskTypeToExclude . ")$/", $arrayTaskData["NEXT_TASK"]["TAS_TYPE"]))? $this->getNextAssignedUser($arrayTaskData) : array("USR_UID" => "", "USR_FULLNAME" => "");
|
|
}
|
|
|
|
//Return
|
|
return $arrayTaskData;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* prepareInformation
|
|
*
|
|
* @param array $arrayData Data
|
|
* @param string $taskUid Unique id of Task
|
|
*
|
|
* @return array Return array
|
|
*/
|
|
public function prepareInformation(array $arrayData, $taskUid = "")
|
|
{
|
|
try {
|
|
if (!class_exists("Cases")) {
|
|
G::LoadClass("case");
|
|
}
|
|
|
|
$this->case = new Cases();
|
|
$task = new Task();
|
|
|
|
$arrayApplicationData = $this->case->loadCase($arrayData["APP_UID"]);
|
|
|
|
$arrayNextTask = array();
|
|
$arrayNextTaskDefault = array();
|
|
$i = 0;
|
|
|
|
//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 = '$arrayData["APP_UID"]'
|
|
//AND DEL_INDEX = '$arrayData["DEL_INDEX"]'
|
|
|
|
$criteria = new Criteria("workflow");
|
|
|
|
$criteria->addSelectColumn(RoutePeer::TAS_UID);
|
|
$criteria->addSelectColumn(RoutePeer::ROU_NEXT_TASK);
|
|
$criteria->addSelectColumn(RoutePeer::ROU_TYPE);
|
|
$criteria->addSelectColumn(RoutePeer::ROU_DEFAULT);
|
|
$criteria->addSelectColumn(RoutePeer::ROU_CONDITION);
|
|
|
|
if ($taskUid != "") {
|
|
$criteria->add(RoutePeer::TAS_UID, $taskUid, Criteria::EQUAL);
|
|
$criteria->addAscendingOrderByColumn(RoutePeer::ROU_CASE);
|
|
|
|
$rsCriteria = RoutePeer::doSelectRS($criteria);
|
|
} else {
|
|
$criteria->addJoin(AppDelegationPeer::TAS_UID, TaskPeer::TAS_UID, Criteria::LEFT_JOIN);
|
|
$criteria->addJoin(AppDelegationPeer::TAS_UID, RoutePeer::TAS_UID, Criteria::LEFT_JOIN);
|
|
$criteria->add(AppDelegationPeer::APP_UID, $arrayData["APP_UID"], Criteria::EQUAL);
|
|
$criteria->add(AppDelegationPeer::DEL_INDEX, $arrayData["DEL_INDEX"], Criteria::EQUAL);
|
|
$criteria->addAscendingOrderByColumn(RoutePeer::ROU_CASE);
|
|
|
|
$rsCriteria = AppDelegationPeer::doSelectRS($criteria);
|
|
}
|
|
|
|
$rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
|
|
$flagDefault = false;
|
|
$aSecJoin = array();
|
|
$count = 0;
|
|
|
|
while ($rsCriteria->next()) {
|
|
$arrayRouteData = G::array_merges($rsCriteria->getRow(), $arrayData);
|
|
|
|
if ((int)($arrayRouteData["ROU_DEFAULT"]) == 1) {
|
|
$arrayNextTaskDefault = $arrayRouteData;
|
|
$flagDefault = true;
|
|
continue;
|
|
}
|
|
|
|
$flagAddDelegation = true;
|
|
|
|
//Evaluate the condition if there are conditions defined
|
|
if (trim($arrayRouteData["ROU_CONDITION"]) != "" && $arrayRouteData["ROU_TYPE"] != "SELECT") {
|
|
G::LoadClass("pmScript");
|
|
|
|
$pmScript = new PMScript();
|
|
$pmScript->setFields($arrayApplicationData["APP_DATA"]);
|
|
$pmScript->setScript($arrayRouteData["ROU_CONDITION"]);
|
|
$flagAddDelegation = $pmScript->evaluate();
|
|
}
|
|
|
|
if (trim($arrayRouteData["ROU_CONDITION"]) == "" && $arrayRouteData["ROU_NEXT_TASK"] != "-1") {
|
|
$arrayTaskData = $task->load($arrayRouteData["ROU_NEXT_TASK"]);
|
|
if ($arrayRouteData["ROU_TYPE"] != "SEC-JOIN" && $arrayTaskData["TAS_TYPE"] == "GATEWAYTOGATEWAY") {
|
|
$flagAddDelegation = true;
|
|
}
|
|
|
|
if($arrayRouteData["ROU_TYPE"] == "SEC-JOIN"){
|
|
$aSecJoin[$count]["ROU_PREVIOUS_TASK"] = $arrayRouteData["ROU_NEXT_TASK"];
|
|
$aSecJoin[$count]["ROU_PREVIOUS_TYPE"] = "SEC-JOIN";
|
|
$count++;
|
|
}
|
|
}
|
|
|
|
if ($arrayRouteData["ROU_TYPE"] == "EVALUATE" && !empty($arrayNextTask)) {
|
|
$flagAddDelegation = false;
|
|
}
|
|
|
|
if ($flagAddDelegation &&
|
|
preg_match("/^(?:EVALUATE|PARALLEL-BY-EVALUATION)$/", $arrayRouteData["ROU_TYPE"]) &&
|
|
trim($arrayRouteData["ROU_CONDITION"]) == ""
|
|
) {
|
|
$flagAddDelegation = false;
|
|
}
|
|
|
|
if ($flagAddDelegation) {
|
|
$arrayNextTask[++$i] = $this->prepareInformationTask($arrayRouteData);
|
|
}
|
|
}
|
|
|
|
if (count($arrayNextTask) == 0 && count($arrayNextTaskDefault) > 0) {
|
|
$arrayNextTask[++$i] = $this->prepareInformationTask($arrayNextTaskDefault);
|
|
}
|
|
|
|
//Check Task GATEWAYTOGATEWAY, END-MESSAGE-EVENT, END-EMAIL-EVENT
|
|
$arrayNextTaskBackup = $arrayNextTask;
|
|
$arrayNextTask = array();
|
|
$i = 0;
|
|
foreach ($arrayNextTaskBackup as $value) {
|
|
$arrayNextTaskData = $value;
|
|
|
|
$regexpTaskTypeToInclude = "GATEWAYTOGATEWAY|END-MESSAGE-EVENT|END-EMAIL-EVENT";
|
|
|
|
if ($arrayNextTaskData["NEXT_TASK"]["TAS_UID"] != "-1" &&
|
|
preg_match("/^(?:" . $regexpTaskTypeToInclude . ")$/", $arrayNextTaskData["NEXT_TASK"]["TAS_TYPE"])
|
|
) {
|
|
$arrayAux = $this->prepareInformation($arrayData, $arrayNextTaskData["NEXT_TASK"]["TAS_UID"]);
|
|
|
|
foreach ($arrayAux as $value2) {
|
|
$arrayNextTask[++$i] = $value2;
|
|
foreach($aSecJoin as $rsj){
|
|
$arrayNextTask[$i]["NEXT_TASK"]["ROU_PREVIOUS_TASK"] = $rsj["ROU_PREVIOUS_TASK"];
|
|
$arrayNextTask[$i]["NEXT_TASK"]["ROU_PREVIOUS_TYPE"] = "SEC-JOIN";
|
|
}
|
|
}
|
|
} else {
|
|
$regexpTaskTypeToInclude = "END-MESSAGE-EVENT|END-EMAIL-EVENT";
|
|
|
|
if ($arrayNextTaskData["NEXT_TASK"]["TAS_UID"] == "-1" &&
|
|
preg_match("/^(?:" . $regexpTaskTypeToInclude . ")$/", $arrayNextTaskData["TAS_TYPE"])
|
|
) {
|
|
$arrayNextTaskData["NEXT_TASK"]["TAS_UID"] = $arrayNextTaskData["TAS_UID"] . "/" . $arrayNextTaskData["NEXT_TASK"]["TAS_UID"];
|
|
}
|
|
|
|
$arrayNextTask[++$i] = $arrayNextTaskData;
|
|
foreach($aSecJoin as $rsj){
|
|
$arrayNextTask[$i]["NEXT_TASK"]["ROU_PREVIOUS_TASK"] = $rsj["ROU_PREVIOUS_TASK"];
|
|
$arrayNextTask[$i]["NEXT_TASK"]["ROU_PREVIOUS_TYPE"] = "SEC-JOIN";
|
|
}
|
|
//Start-Timer with Script-task
|
|
$criteriaE = new Criteria("workflow");
|
|
$criteriaE->addSelectColumn(ElementTaskRelationPeer::ELEMENT_UID);
|
|
$criteriaE->addJoin(BpmnEventPeer::EVN_UID, ElementTaskRelationPeer::ELEMENT_UID, Criteria::LEFT_JOIN);
|
|
$criteriaE->add(ElementTaskRelationPeer::TAS_UID, $arrayNextTaskData["TAS_UID"], Criteria::EQUAL);
|
|
$criteriaE->add(BpmnEventPeer::EVN_TYPE, 'START', Criteria::EQUAL);
|
|
$criteriaE->add(BpmnEventPeer::EVN_MARKER, 'TIMER', Criteria::EQUAL);
|
|
$rsCriteriaE = AppDelegationPeer::doSelectRS($criteriaE);
|
|
$rsCriteriaE->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
while ($rsCriteriaE->next()) {
|
|
if($arrayNextTaskData["NEXT_TASK"]["TAS_TYPE"] == "SCRIPT-TASK"){
|
|
if(isset($arrayNextTaskData["NEXT_TASK"]["USER_ASSIGNED"]["USR_UID"]) && $arrayNextTaskData["NEXT_TASK"]["USER_ASSIGNED"]["USR_UID"] == ""){
|
|
$useruid = "00000000000000000000000000000001";
|
|
$userFields = $this->getUsersFullNameFromArray( $useruid );
|
|
$arrayNextTask[$i]["NEXT_TASK"]["USER_ASSIGNED"] = $userFields;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//1. There is no rule
|
|
if (empty($arrayNextTask)) {
|
|
$bpmn = new \ProcessMaker\Project\Bpmn();
|
|
|
|
throw new Exception(G::LoadTranslation(
|
|
'ID_NO_DERIVATION_' . (($bpmn->exists($arrayApplicationData['PRO_UID']))? 'BPMN_RULE' : 'RULE')
|
|
));
|
|
}
|
|
|
|
//Return
|
|
return $arrayNextTask;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
/* get all users, from any task, if the task have Groups, the function expand the group
|
|
*
|
|
* @param string $sTasUid the task uidUser
|
|
* @param bool $flagIncludeAdHocUsers
|
|
* @return Array $users an array with userID order by USR_UID
|
|
*/
|
|
function getAllUsersFromAnyTask($sTasUid, $flagIncludeAdHocUsers = false)
|
|
{
|
|
$users = array ();
|
|
$c = new Criteria( 'workflow' );
|
|
$c->clearSelectColumns();
|
|
$c->addSelectColumn( TaskUserPeer::USR_UID );
|
|
$c->addSelectColumn( TaskUserPeer::TU_RELATION );
|
|
$c->add( TaskUserPeer::TAS_UID, $sTasUid );
|
|
|
|
if ($flagIncludeAdHocUsers) {
|
|
$c->add(
|
|
$c->getNewCriterion(TaskUserPeer::TU_TYPE, 1, Criteria::EQUAL)->addOr(
|
|
$c->getNewCriterion(TaskUserPeer::TU_TYPE, 2, Criteria::EQUAL))
|
|
);
|
|
} else {
|
|
$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 );
|
|
$cGrp->add( UsersPeer::USR_STATUS, 'INACTIVE', Criteria::NOT_EQUAL );
|
|
$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();
|
|
}
|
|
//to do: different types of sort
|
|
sort( $users );
|
|
|
|
return $users;
|
|
}
|
|
|
|
/* get an array of users, and returns the same arrays with User's fullname and other fields
|
|
*
|
|
* @param Array $aUsers the task uidUser
|
|
* @return Array $aUsersData an array with with User's fullname
|
|
*/
|
|
function getUsersFullNameFromArray ($aUsers)
|
|
{
|
|
$oUser = new Users();
|
|
$aUsersData = array ();
|
|
if (is_array( $aUsers )) {
|
|
foreach ($aUsers as $key => $val) {
|
|
// $userFields = $oUser->load( $val );
|
|
$userFields = $oUser->userVacation( $val );
|
|
$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;
|
|
}
|
|
|
|
/* get next assigned user
|
|
*
|
|
* @param Array $tasInfo
|
|
* @return Array $userFields
|
|
*/
|
|
function getNextAssignedUser ($tasInfo)
|
|
{
|
|
//$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" */
|
|
|
|
$taskNext = TaskPeer::retrieveByPK($nextAssignedTask["TAS_UID"]);
|
|
$bpmnActivityNext = BpmnActivityPeer::retrieveByPK($nextAssignedTask["TAS_UID"]);
|
|
|
|
$flagTaskNextIsMultipleInstance = false;
|
|
$flagTaskNextAssignTypeIsMultipleInstance = false;
|
|
|
|
if (!is_null($taskNext) && !is_null($bpmnActivityNext)) {
|
|
$flagTaskNextIsMultipleInstance = $bpmnActivityNext->getActType() == "TASK" && preg_match("/^(?:EMPTY|SENDTASK|RECEIVETASK|USERTASK|SERVICETASK|MANUALTASK|BUSINESSRULE)$/", $bpmnActivityNext->getActTaskType()) && $bpmnActivityNext->getActLoopType() == "PARALLEL";
|
|
$flagTaskNextAssignTypeIsMultipleInstance = preg_match("/^(?:MULTIPLE_INSTANCE|MULTIPLE_INSTANCE_VALUE_BASED)$/", $taskNext->getTasAssignType());
|
|
}
|
|
|
|
$taskNextAssignType = $taskNext->getTasAssignType();
|
|
$taskNextAssignType = ($flagTaskNextIsMultipleInstance && !$flagTaskNextAssignTypeIsMultipleInstance)? "" : $taskNextAssignType;
|
|
$taskNextAssignType = (!$flagTaskNextIsMultipleInstance && $flagTaskNextAssignTypeIsMultipleInstance)? "" : $taskNextAssignType;
|
|
|
|
switch ($taskNextAssignType) {
|
|
case 'BALANCED':
|
|
$users = $this->getAllUsersFromAnyTask( $sTasUid );
|
|
$uidUser = "";
|
|
|
|
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) {
|
|
if ($lastAssigned < $users[$i]) {
|
|
$uidUser = $users[$i];
|
|
}
|
|
$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." ));
|
|
}
|
|
} else {
|
|
throw (new Exception( "Task doesn't have a valid user in variable $variable or this variable doesn't exist." ));
|
|
}
|
|
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
|
|
$useruid = ($tasInfo["USER_UID"] != "")? $this->checkReplacedByUser($this->getDenpendentUser($tasInfo["USER_UID"])) : "";
|
|
|
|
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;
|
|
case "MULTIPLE_INSTANCE":
|
|
$userFields = $this->getUsersFullNameFromArray($this->getAllUsersFromAnyTask($nextAssignedTask["TAS_UID"]));
|
|
if(empty($userFields)){
|
|
throw (new Exception( G::LoadTranslation( 'ID_NO_USERS' ) ));
|
|
}
|
|
break;
|
|
case "MULTIPLE_INSTANCE_VALUE_BASED":
|
|
$arrayApplicationData = $this->case->loadCase($tasInfo["APP_UID"]);
|
|
|
|
$nextTaskAssignVariable = trim($nextAssignedTask["TAS_ASSIGN_VARIABLE"], " @#");
|
|
|
|
if ($nextTaskAssignVariable != "" &&
|
|
isset($arrayApplicationData["APP_DATA"][$nextTaskAssignVariable]) && !empty($arrayApplicationData["APP_DATA"][$nextTaskAssignVariable]) && is_array($arrayApplicationData["APP_DATA"][$nextTaskAssignVariable])
|
|
) {
|
|
$userFields = $this->getUsersFullNameFromArray($arrayApplicationData["APP_DATA"][$nextTaskAssignVariable]);
|
|
} else {
|
|
throw new Exception(G::LoadTranslation("ID_ACTIVITY_INVALID_USER_DATA_VARIABLE_FOR_MULTIPLE_INSTANCE_ACTIVITY", array(strtolower("ACT_UID"), $nextAssignedTask["TAS_UID"], $nextTaskAssignVariable)));
|
|
}
|
|
break;
|
|
default:
|
|
throw (new Exception( 'Invalid Task Assignment method for Next Task ' ));
|
|
break;
|
|
}
|
|
return $userFields;
|
|
}
|
|
|
|
/* getDenpendentUser
|
|
*
|
|
* @param string $USR_UID
|
|
* @return string $aRow['USR_REPORTS_TO']
|
|
*/
|
|
function getDenpendentUser ($USR_UID)
|
|
{
|
|
$user = new \ProcessMaker\BusinessModel\User();
|
|
|
|
$manager = $user->getUsersManager($USR_UID);
|
|
|
|
//Return
|
|
return ($manager !== false)? $manager : $USR_UID;
|
|
}
|
|
|
|
/* setTasLastAssigned
|
|
*
|
|
* @param string $tasUid
|
|
* @param string $usrUid
|
|
* @throws Exception $e
|
|
* @return void
|
|
*/
|
|
function setTasLastAssigned ($tasUid, $usrUid)
|
|
{
|
|
try {
|
|
$oTask = TaskPeer::retrieveByPk( $tasUid );
|
|
$oTask->setTasLastAssigned( $usrUid );
|
|
$oTask->save();
|
|
} catch (Exception $e) {
|
|
throw ($e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Throw Events for the Case
|
|
*
|
|
* @param string $elementOriginUid Unique id of Element Origin (unique id of Task)
|
|
* @param string $elementDestUid Unique id of Element Destination (unique id of Task)
|
|
* @param array $arrayApplicationData Case data
|
|
* @param bool $flagEventExecuteBeforeGateway Execute event before gateway
|
|
* @param bool $flagEventExecuteAfterGateway Execute event after gateway
|
|
*
|
|
* @return void
|
|
*/
|
|
private function throwEventsBetweenElementOriginAndElementDest($elementOriginUid, $elementDestUid, array $arrayApplicationData, $flagEventExecuteBeforeGateway = true, $flagEventExecuteAfterGateway = true, $rouCondition="")
|
|
{
|
|
try {
|
|
//Verify if the Project is BPMN
|
|
$bpmn = new \ProcessMaker\Project\Bpmn();
|
|
|
|
if (!$bpmn->exists($arrayApplicationData["PRO_UID"])) {
|
|
return;
|
|
}
|
|
|
|
//Element origin and dest
|
|
$elementTaskRelation = new \ProcessMaker\BusinessModel\ElementTaskRelation();
|
|
|
|
$arrayElement = [
|
|
"elementOrigin" => ["uid" => $elementOriginUid, "type" => "bpmnActivity"],
|
|
"elementDest" => ["uid" => $elementDestUid, "type" => "bpmnActivity"]
|
|
];
|
|
|
|
foreach ($arrayElement as $key => $value) {
|
|
$arrayElementTaskRelationData = $elementTaskRelation->getElementTaskRelationWhere(
|
|
[
|
|
ElementTaskRelationPeer::PRJ_UID => $arrayApplicationData["PRO_UID"],
|
|
ElementTaskRelationPeer::ELEMENT_TYPE => "bpmnEvent",
|
|
ElementTaskRelationPeer::TAS_UID => $arrayElement[$key]["uid"]
|
|
],
|
|
true
|
|
);
|
|
|
|
if (!is_null($arrayElementTaskRelationData)) {
|
|
$arrayElement[$key]["uid"] = $arrayElementTaskRelationData["ELEMENT_UID"];
|
|
$arrayElement[$key]["type"] = "bpmnEvent";
|
|
}
|
|
}
|
|
|
|
$elementOriginUid = $arrayElement["elementOrigin"]["uid"];
|
|
$elementOriginType = $arrayElement["elementOrigin"]["type"];
|
|
$elementDestUid = $arrayElement["elementDest"]["uid"];
|
|
$elementDestType = $arrayElement["elementDest"]["type"];
|
|
|
|
//Throw Events
|
|
$messageApplication = new \ProcessMaker\BusinessModel\MessageApplication();
|
|
$emailEvent = new \ProcessMaker\BusinessModel\EmailEvent();
|
|
|
|
$arrayEventExecute = ["BEFORE" => $flagEventExecuteBeforeGateway, "AFTER" => $flagEventExecuteAfterGateway];
|
|
$positionEventExecute = "BEFORE";
|
|
|
|
$arrayElement = $bpmn->getElementsBetweenElementOriginAndElementDest(
|
|
$elementOriginUid,
|
|
$elementOriginType,
|
|
$elementDestUid,
|
|
$elementDestType
|
|
);
|
|
|
|
//Search next is INTERMEDIATE and MESSAGECATCH
|
|
$searchMessageCatch = false;
|
|
if($elementDestType === 'bpmnEvent'){
|
|
$c = new Criteria("workflow");
|
|
$c->addSelectColumn(BpmnEventPeer::EVN_TYPE);
|
|
$c->addSelectColumn(BpmnEventPeer::EVN_MARKER);
|
|
$c->add(BpmnEventPeer::EVN_UID, $elementDestUid);
|
|
$c->add(BpmnEventPeer::PRJ_UID, $arrayApplicationData["PRO_UID"]);
|
|
$rsC = RoutePeer::doSelectRS($c);
|
|
$rsC->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
|
|
if($rsC->next()){
|
|
$row = $rsC->getRow();
|
|
if($row['EVN_TYPE'] === 'INTERMEDIATE' && $row['EVN_MARKER'] === 'MESSAGECATCH'){
|
|
$searchMessageCatch = true;
|
|
}
|
|
}
|
|
}
|
|
if($elementDestUid === '-1' || count($arrayElement) === 0 || $searchMessageCatch){
|
|
$arrayElement = $this->throwElementToEnd($elementOriginUid, $rouCondition);
|
|
}
|
|
|
|
foreach ($arrayElement as $value) {
|
|
switch ($value[1]) {
|
|
case 'bpmnEvent':
|
|
if ($arrayEventExecute[$positionEventExecute]) {
|
|
$event = \BpmnEventPeer::retrieveByPK($value[0]);
|
|
|
|
if (!is_null($event)) {
|
|
if (preg_match("/^(?:END|INTERMEDIATE)$/", $event->getEvnType()) && $event->getEvnMarker() === 'MESSAGETHROW') {
|
|
//Message-Application throw
|
|
$result = $messageApplication->create($arrayApplicationData["APP_UID"], $arrayApplicationData["PRO_UID"], $value[0], $arrayApplicationData);
|
|
}
|
|
|
|
if (preg_match("/^(?:END|INTERMEDIATE)$/", $event->getEvnType()) && $event->getEvnMarker() === 'EMAIL') {
|
|
//Email-Event throw
|
|
$result = $emailEvent->sendEmail($arrayApplicationData["APP_UID"], $arrayApplicationData["PRO_UID"], $value[0], $arrayApplicationData);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 'bpmnGateway':
|
|
$positionEventExecute = 'AFTER';
|
|
break;
|
|
}
|
|
}
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Throw all events to End Process
|
|
*
|
|
* @param string $currentTask Task uid
|
|
*
|
|
* @return void
|
|
*/
|
|
private function throwElementToEnd($currentTask, $routeCondition){
|
|
try{
|
|
$bpmnFlow = new BpmnFlow();
|
|
$rsCriFlow = $bpmnFlow->getElementOriginToElementDest($currentTask);
|
|
$arrayElement = array();
|
|
$count = 0;
|
|
$continue = false;
|
|
if($rsCriFlow->next()){
|
|
$continue = true;
|
|
$row = $rsCriFlow->getRow();
|
|
}
|
|
while ($continue) {
|
|
$array[0] = $row["FLO_ELEMENT_DEST"];
|
|
$array[1] = $row["FLO_ELEMENT_DEST_TYPE"];
|
|
$arrayElement[$count++] = $array;
|
|
$continue = false;
|
|
if($rsCriFlow->next()){
|
|
$continue = true;
|
|
$row = $rsCriFlow->getRow();
|
|
}else{
|
|
$rsCriFlow = $bpmnFlow->getElementOriginToElementDest($row["FLO_ELEMENT_DEST"],$routeCondition,"bpmnEvent");
|
|
$routeCondition = '';
|
|
$continue = false;
|
|
if($rsCriFlow->next()){
|
|
$continue = true;
|
|
$row = $rsCriFlow->getRow();
|
|
}
|
|
}
|
|
}
|
|
return $arrayElement;
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Throw Events for the Case
|
|
*
|
|
* @param string $currentTask Task uid
|
|
*
|
|
* @return void
|
|
*/
|
|
private function throwAllRouteInFlow($currentTask,$appFields){
|
|
$criFlow = new Criteria("workflow");
|
|
$criFlow->addSelectColumn(BpmnFlowPeer::FLO_ELEMENT_ORIGIN);
|
|
$criFlow->addSelectColumn(BpmnFlowPeer::FLO_ELEMENT_DEST);
|
|
$criFlow->add(BpmnFlowPeer::FLO_ELEMENT_ORIGIN, $currentTask, Criteria::EQUAL);
|
|
$rsCriFlow = RoutePeer::doSelectRS($criFlow);
|
|
$rsCriFlow->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
if($rsCriFlow->next()){
|
|
$continue = true;
|
|
$row = $rsCriFlow->getRow();
|
|
}
|
|
while ($continue) {
|
|
$origin = $row["FLO_ELEMENT_ORIGIN"];
|
|
$destiny = $row["FLO_ELEMENT_DEST"];
|
|
$this->throwEventsElemntOriginToElementDest($destiny, $appFields);
|
|
$currentDestiny = $destiny;
|
|
$continue = false;
|
|
if($rsCriFlow->next()){
|
|
$continue = true;
|
|
$row = $rsCriFlow->getRow();
|
|
}else{
|
|
//Search the next
|
|
$criFlow = new Criteria("workflow");
|
|
$criFlow->addSelectColumn(BpmnFlowPeer::FLO_ELEMENT_ORIGIN);
|
|
$criFlow->addSelectColumn(BpmnFlowPeer::FLO_ELEMENT_DEST);
|
|
$criFlow->add(BpmnFlowPeer::FLO_ELEMENT_ORIGIN, $currentDestiny, Criteria::EQUAL);
|
|
$rsCriFlow = RoutePeer::doSelectRS($criFlow);
|
|
$rsCriFlow->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$continue = false;
|
|
if($rsCriFlow->next()){
|
|
$continue = true;
|
|
$row = $rsCriFlow->getRow();
|
|
}
|
|
}
|
|
}
|
|
return $currentDestiny;
|
|
}
|
|
|
|
/**
|
|
* Throw Events for the Case
|
|
*
|
|
* @param string $eventUid Unique id of Event
|
|
* @param array $appFields Case data
|
|
*
|
|
* @return void
|
|
*/
|
|
private function throwEventsElemntOriginToElementDest($eventUid, $appFields){
|
|
try {
|
|
//Verify if the Project is BPMN
|
|
$bpmn = new \ProcessMaker\Project\Bpmn();
|
|
|
|
if (!$bpmn->exists($appFields["PRO_UID"])) {
|
|
return;
|
|
}
|
|
//Throw Events
|
|
$messageApplication = new \ProcessMaker\BusinessModel\MessageApplication();
|
|
$emailEvent = new \ProcessMaker\BusinessModel\EmailEvent();
|
|
|
|
$event = \BpmnEventPeer::retrieveByPK($eventUid);
|
|
if (!is_null($event)) {
|
|
if (preg_match("/^(?:END|INTERMEDIATE)$/", $event->getEvnType()) && $event->getEvnMarker() == "MESSAGETHROW") {
|
|
//Message-Application throw
|
|
$result = $messageApplication->create($appFields["APP_UID"], $appFields["PRO_UID"], $value[0], $appFields);
|
|
}
|
|
|
|
if (preg_match("/^(?:END|INTERMEDIATE)$/", $event->getEvnType()) && $event->getEvnMarker() == "EMAIL") {
|
|
//Email-Event throw
|
|
$result = $emailEvent->sendEmail($appFields["APP_UID"], $appFields["PRO_UID"], $eventUid, $appFields);
|
|
}
|
|
}
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update counters
|
|
*
|
|
* @param array $arrayCurrentDelegationData
|
|
* @param array $arrayNextDelegationData
|
|
* @param mixed $taskNextDelegation
|
|
* @param array $arrayApplicationData
|
|
* @param int $delIndexNew
|
|
* @param mixed $aSp
|
|
* @param bool $removeList
|
|
*
|
|
* @return void
|
|
*/
|
|
private function derivateUpdateCounters(array $arrayCurrentDelegationData, array $arrayNextDelegationData, $taskNextDelegation, array $arrayApplicationData, $delIndexNew, $aSp, $removeList)
|
|
{
|
|
/*----------------------------------********---------------------------------*/
|
|
try {
|
|
$user = new Users();
|
|
|
|
if ($arrayNextDelegationData["TAS_UID"] == "-2") {
|
|
$application = ApplicationPeer::retrieveByPK($arrayApplicationData["APP_UID"]);
|
|
|
|
if ($application->getAppStatus() == "DRAFT") {
|
|
//$user->refreshTotal($arrayApplicationData["CURRENT_USER_UID"], "remove", "draft");
|
|
} else {
|
|
//$user->refreshTotal($arrayApplicationData["CURRENT_USER_UID"], "remove", "inbox");
|
|
}
|
|
} else {
|
|
if ($arrayNextDelegationData["TAS_UID"] != "-1") {
|
|
$regexpTaskTypeToExclude = "WEBENTRYEVENT|END-MESSAGE-EVENT|START-MESSAGE-EVENT|INTERMEDIATE-THROW-MESSAGE-EVENT|INTERMEDIATE-CATCH-MESSAGE-EVENT|SCRIPT-TASK|INTERMEDIATE-CATCH-TIMER-EVENT";
|
|
|
|
if (!preg_match("/^(?:" . $regexpTaskTypeToExclude . ")$/", $taskNextDelegation->getTasType())) {
|
|
if (!empty($delIndexNew) && empty($aSp)) {
|
|
$appDelegation = AppDelegationPeer::retrieveByPK($arrayApplicationData["APP_UID"], $delIndexNew);
|
|
$arrayApplicationData2 = $appDelegation->toArray(BasePeer::TYPE_FIELDNAME);
|
|
|
|
$arrayApplicationData2["APP_STATUS"] = $arrayCurrentDelegationData["APP_STATUS"];
|
|
|
|
$taskCurrent = TaskPeer::retrieveByPK($arrayCurrentDelegationData["TAS_UID"]);
|
|
|
|
if ($taskCurrent->getTasType() == "INTERMEDIATE-CATCH-MESSAGE-EVENT") {
|
|
$removeList = false;
|
|
}
|
|
|
|
$arrayApplicationData2["REMOVED_LIST"] = $removeList;
|
|
|
|
$inbox = new ListInbox();
|
|
$inbox->newRow($arrayApplicationData2, $arrayApplicationData["CURRENT_USER_UID"], false, array(), (($arrayNextDelegationData["TAS_ASSIGN_TYPE"] == "SELF_SERVICE")? true : false));
|
|
} else {
|
|
if (empty($aSp)) {
|
|
$application = ApplicationPeer::retrieveByPK($arrayApplicationData["APP_UID"]);
|
|
|
|
if ($application->getAppStatus() == "DRAFT") {
|
|
//$user->refreshTotal($arrayApplicationData["CURRENT_USER_UID"], "remove", "draft");
|
|
} else {
|
|
//$user->refreshTotal($arrayApplicationData["CURRENT_USER_UID"], "remove", "inbox");
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if ($removeList) {
|
|
$application = ApplicationPeer::retrieveByPK($arrayApplicationData["APP_UID"]);
|
|
|
|
if ($application->getAppStatus() == "DRAFT") {
|
|
//$user->refreshTotal($arrayApplicationData["CURRENT_USER_UID"], "remove", "draft");
|
|
} else {
|
|
//$user->refreshTotal($arrayApplicationData["CURRENT_USER_UID"], "remove", "inbox");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (Exception $e) {
|
|
throw $e;
|
|
}
|
|
/*----------------------------------********---------------------------------*/
|
|
}
|
|
|
|
/** Derivate
|
|
*
|
|
* @param array $currentDelegation
|
|
* @param array $nextDelegations
|
|
* @param bool $removeList
|
|
*
|
|
* @return void
|
|
*/
|
|
function derivate(array $currentDelegation, array $nextDelegations, $removeList = true)
|
|
{
|
|
$arrayDerivationResult = [];
|
|
|
|
//define this...
|
|
if (! defined( 'TASK_FINISH_PROCESS' )) {
|
|
define( 'TASK_FINISH_PROCESS', - 1 );
|
|
}
|
|
if (! defined( 'TASK_FINISH_TASK' )) {
|
|
define( 'TASK_FINISH_TASK', - 2 );
|
|
}
|
|
|
|
$this->case = new cases();
|
|
|
|
//Get data for this DEL_INDEX current
|
|
$appFields = $this->case->loadCase( $currentDelegation['APP_UID'], $currentDelegation['DEL_INDEX'] );
|
|
|
|
//We close the current derivation, then we'll try to derivate to each defined route
|
|
$this->case->CloseCurrentDelegation( $currentDelegation['APP_UID'], $currentDelegation['DEL_INDEX'] );
|
|
|
|
//Get data for current delegation (current Task)
|
|
$task = TaskPeer::retrieveByPK($currentDelegation["TAS_UID"]);
|
|
$bpmnActivity = BpmnActivityPeer::retrieveByPK($currentDelegation["TAS_UID"]);
|
|
|
|
$flagTaskIsMultipleInstance = false;
|
|
$flagTaskAssignTypeIsMultipleInstance = false;
|
|
|
|
if (!is_null($task) && !is_null($bpmnActivity)) {
|
|
$flagTaskIsMultipleInstance = $bpmnActivity->getActType() == "TASK" && preg_match("/^(?:EMPTY|USERTASK|MANUALTASK)$/", $bpmnActivity->getActTaskType()) && $bpmnActivity->getActLoopType() == "PARALLEL";
|
|
$flagTaskAssignTypeIsMultipleInstance = preg_match("/^(?:MULTIPLE_INSTANCE|MULTIPLE_INSTANCE_VALUE_BASED)$/", $task->getTasAssignType());
|
|
}
|
|
|
|
$currentDelegation["TAS_ASSIGN_TYPE"] = $task->getTasAssignType();
|
|
$currentDelegation["TAS_MI_COMPLETE_VARIABLE"] = $task->getTasMiCompleteVariable();
|
|
$currentDelegation["TAS_MI_INSTANCE_VARIABLE"] = $task->getTasMiInstanceVariable();
|
|
|
|
$arrayNextDerivation = array();
|
|
$flagFirstIteration = true;
|
|
|
|
foreach ($nextDelegations as $nextDel) {
|
|
//BpmnEvent - END-MESSAGE-EVENT, END-EMAIL-EVENT
|
|
//Check and get unique id
|
|
if (preg_match("/^(.{32})\/(\-1)$/", $nextDel["TAS_UID"], $arrayMatch)) {
|
|
$nextDel["TAS_UID"] = $arrayMatch[2];
|
|
$nextDel["TAS_UID_DUMMY"] = $arrayMatch[1];
|
|
}
|
|
|
|
//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();
|
|
$oTask = new Task();
|
|
$aTaskNext = $oTask->load( $nextDel['TAS_UID'] );
|
|
//When is MULTIPLE_INSTANCE catch the first user
|
|
if($aTaskNext["TAS_ASSIGN_TYPE"] == "MULTIPLE_INSTANCE"){
|
|
$spUserUid = $this->getAllUsersFromAnyTask($nextDel["TAS_UID"]);
|
|
foreach($spUserUid as $row){
|
|
$firstUserUid = $row;
|
|
continue;
|
|
}
|
|
$aSP['USR_UID'] = $firstUserUid;
|
|
}else{
|
|
$aSP['USR_UID'] = $nextDel['USR_UID'];
|
|
}
|
|
$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 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;
|
|
}
|
|
|
|
$taskNextDel = TaskPeer::retrieveByPK($nextDel["TAS_UID"]); //Get data for next delegation (next Task)
|
|
$bpmnActivityNextDel = BpmnActivityPeer::retrieveByPK($nextDel["TAS_UID"]);
|
|
|
|
$flagTaskNextDelIsMultipleInstance = false;
|
|
$flagTaskNextDelAssignTypeIsMultipleInstance = false;
|
|
|
|
if (!is_null($taskNextDel) && !is_null($bpmnActivityNextDel)) {
|
|
$flagTaskNextDelIsMultipleInstance = $bpmnActivityNextDel->getActType() == "TASK" && preg_match("/^(?:EMPTY|USERTASK|MANUALTASK)$/", $bpmnActivityNextDel->getActTaskType()) && $bpmnActivityNextDel->getActLoopType() == "PARALLEL";
|
|
$flagTaskNextDelAssignTypeIsMultipleInstance = preg_match("/^(?:MULTIPLE_INSTANCE|MULTIPLE_INSTANCE_VALUE_BASED)$/", $taskNextDel->getTasAssignType());
|
|
}
|
|
|
|
$flagUpdateCounters = true;
|
|
|
|
switch ($nextDel['TAS_UID']) {
|
|
case TASK_FINISH_PROCESS:
|
|
/*Close all delegations of $currentDelegation['APP_UID'] */
|
|
$this->case->closeAllDelegations( $currentDelegation['APP_UID'] );
|
|
$this->case->closeAllThreads( $currentDelegation['APP_UID'] );
|
|
//I think we need to change the APP_STATUS to completed,
|
|
if (!isset($nextDel['ROU_CONDITION'])) {
|
|
$nextDel['ROU_CONDITION'] = '';
|
|
}
|
|
if (isset($nextDel["TAS_UID_DUMMY"]) ) {
|
|
$taskDummy = TaskPeer::retrieveByPK($nextDel["TAS_UID_DUMMY"]);
|
|
if (preg_match("/^(?:END-MESSAGE-EVENT|END-EMAIL-EVENT)$/", $taskDummy->getTasType())) {
|
|
//Throw Events
|
|
$this->throwEventsBetweenElementOriginAndElementDest($currentDelegation["TAS_UID"], $nextDel["TAS_UID_DUMMY"], $appFields, $flagFirstIteration, true, $nextDel['ROU_CONDITION']);
|
|
} else {
|
|
$this->throwEventsBetweenElementOriginAndElementDest($currentDelegation["TAS_UID"], $nextDel["TAS_UID"], $appFields, $flagFirstIteration, true, $nextDel['ROU_CONDITION']);
|
|
}
|
|
} else {
|
|
//BpmnEvent
|
|
$this->throwEventsBetweenElementOriginAndElementDest($currentDelegation["TAS_UID"], $nextDel["TAS_UID"], $appFields, $flagFirstIteration, true, $nextDel['ROU_CONDITION']);
|
|
}
|
|
break;
|
|
case TASK_FINISH_TASK:
|
|
$iAppThreadIndex = $appFields['DEL_THREAD'];
|
|
$this->case->closeAppThread( $currentDelegation['APP_UID'], $iAppThreadIndex );
|
|
break;
|
|
default:
|
|
//Get all siblingThreads
|
|
$canDerivate = false;
|
|
|
|
switch ($currentDelegation['TAS_ASSIGN_TYPE']) {
|
|
case 'CANCEL_MI':
|
|
case 'STATIC_MI':
|
|
$arrayOpenThread = $this->case->GetAllOpenDelegation($currentDelegation);
|
|
$aData = $this->case->loadCase( $currentDelegation['APP_UID'] );
|
|
|
|
if (isset( $aData['APP_DATA'][str_replace( '@@', '', $currentDelegation['TAS_MI_INSTANCE_VARIABLE'] )] )) {
|
|
$sMIinstanceVar = $aData['APP_DATA'][str_replace( '@@', '', $currentDelegation['TAS_MI_INSTANCE_VARIABLE'] )];
|
|
} else {
|
|
$sMIinstanceVar = $aData['APP_DATA']['TAS_MI_INSTANCE_VARIABLE'];
|
|
}
|
|
|
|
if (isset( $aData['APP_DATA'][str_replace( '@@', '', $currentDelegation['TAS_MI_COMPLETE_VARIABLE'] )] )) {
|
|
$sMIcompleteVar = $aData['APP_DATA'][str_replace( '@@', '', $currentDelegation['TAS_MI_COMPLETE_VARIABLE'] )];
|
|
} else {
|
|
$sMIcompleteVar = $aData['APP_DATA']['TAS_MI_COMPLETE_VARIABLE'];
|
|
}
|
|
|
|
$discriminateThread = $sMIinstanceVar - $sMIcompleteVar;
|
|
|
|
// -1 because One App Delegation is closed by above Code
|
|
if ($discriminateThread == count($arrayOpenThread)) {
|
|
$canDerivate = true;
|
|
} else {
|
|
$canDerivate = false;
|
|
}
|
|
break;
|
|
default:
|
|
$routeType = $currentDelegation["ROU_TYPE"];
|
|
$routeType = ($flagTaskIsMultipleInstance && $flagTaskAssignTypeIsMultipleInstance)? "SEC-JOIN" : $routeType;
|
|
|
|
switch ($routeType) {
|
|
case "SEC-JOIN":
|
|
$arrayOpenThread = ($flagTaskIsMultipleInstance && $flagTaskAssignTypeIsMultipleInstance)? $this->case->searchOpenPreviousTasks($currentDelegation["TAS_UID"], $currentDelegation["APP_UID"]) : array();
|
|
$arraySiblings = $this->case->getOpenSiblingThreads($nextDel["TAS_UID"], $currentDelegation["APP_UID"], $currentDelegation["DEL_INDEX"], $currentDelegation["TAS_UID"]);
|
|
if(is_array($arrayOpenThread) && is_array($arraySiblings)){
|
|
$arrayOpenThread = array_merge($arrayOpenThread, $arraySiblings);
|
|
}
|
|
$canDerivate = empty($arrayOpenThread);
|
|
if($canDerivate){
|
|
if($flagTaskIsMultipleInstance && $flagTaskAssignTypeIsMultipleInstance){
|
|
$this->flagControlMulInstance = true;
|
|
}else{
|
|
$this->flagControl = true;
|
|
}
|
|
}
|
|
|
|
break;
|
|
default:
|
|
$canDerivate = true;
|
|
//Check if the previous is a SEC-JOIN and check threads
|
|
if(isset($nextDel["ROU_PREVIOUS_TYPE"])){
|
|
if($nextDel["ROU_PREVIOUS_TYPE"] == "SEC-JOIN"){
|
|
$arrayOpenThread = $this->case->searchOpenPreviousTasks($nextDel["ROU_PREVIOUS_TASK"], $currentDelegation["APP_UID"]);
|
|
$canDerivate = empty($arrayOpenThread);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ($canDerivate) {
|
|
$rouCondition = '';
|
|
if(isset($nextDel['ROU_CONDITION'])){
|
|
$rouCondition = $nextDel['ROU_CONDITION'];
|
|
}
|
|
//Throw Events
|
|
$this->throwEventsBetweenElementOriginAndElementDest($currentDelegation["TAS_UID"], $nextDel["TAS_UID"], $appFields, $flagFirstIteration, true, $rouCondition);
|
|
|
|
//Derivate
|
|
$aSP = (isset($aSP))? $aSP : null;
|
|
|
|
$taskNextDelAssignType = ($flagTaskNextDelIsMultipleInstance && $flagTaskNextDelAssignTypeIsMultipleInstance)? $taskNextDel->getTasAssignType() : "";
|
|
|
|
switch ($taskNextDelAssignType) {
|
|
case "MULTIPLE_INSTANCE":
|
|
case "MULTIPLE_INSTANCE_VALUE_BASED":
|
|
$arrayUser = $this->getNextAssignedUser(array("APP_UID" => $currentDelegation["APP_UID"], "NEXT_TASK" => $taskNextDel->toArray(BasePeer::TYPE_FIELDNAME)));
|
|
|
|
if (empty($arrayUser)) {
|
|
throw new Exception(G::LoadTranslation("ID_NO_USERS"));
|
|
}
|
|
|
|
foreach ($arrayUser as $value2) {
|
|
$currentDelegationAux = array_merge($currentDelegation, array("ROU_TYPE" => "PARALLEL"));
|
|
$nextDelAux = array_merge($nextDel, array("USR_UID" => $value2["USR_UID"]));
|
|
|
|
$iNewDelIndex = $this->doDerivation($currentDelegationAux, $nextDelAux, $appFields, $aSP);
|
|
|
|
$this->derivateUpdateCounters($currentDelegationAux, $nextDelAux, $taskNextDel, $appFields, $iNewDelIndex, $aSP, $removeList);
|
|
|
|
$flagUpdateCounters = false;
|
|
$removeList = false;
|
|
|
|
$arrayDerivationResult[] = ['DEL_INDEX' => $iNewDelIndex, 'TAS_UID' => $nextDelAux['TAS_UID'], 'USR_UID' => (isset($nextDelAux['USR_UID']))? $nextDelAux['USR_UID'] : ''];
|
|
}
|
|
break;
|
|
default:
|
|
$iNewDelIndex = $this->doDerivation($currentDelegation, $nextDel, $appFields, $aSP);
|
|
if($iNewDelIndex !== 0){
|
|
$arrayDerivationResult[] = ['DEL_INDEX' => $iNewDelIndex, 'TAS_UID' => $nextDel['TAS_UID'], 'USR_UID' => (isset($nextDel['USR_UID']))? $nextDel['USR_UID'] : ''];
|
|
}
|
|
break;
|
|
}
|
|
|
|
//Execute Script-Task
|
|
$scriptTask = new \ProcessMaker\BusinessModel\ScriptTask();
|
|
|
|
$appFields["APP_DATA"] = $scriptTask->execScriptByActivityUid($nextDel["TAS_UID"], $appFields);
|
|
|
|
//Create record in table APP_ASSIGN_SELF_SERVICE_VALUE
|
|
$regexpTaskTypeToExclude = "SCRIPT-TASK";
|
|
|
|
if (!is_null($taskNextDel) && !preg_match("/^(?:" . $regexpTaskTypeToExclude . ")$/", $taskNextDel->getTasType())) {
|
|
if ($taskNextDel->getTasAssignType() == "SELF_SERVICE" && trim($taskNextDel->getTasGroupVariable()) != "") {
|
|
$nextTaskGroupVariable = trim($taskNextDel->getTasGroupVariable(), " @#");
|
|
|
|
if (isset($appFields["APP_DATA"][$nextTaskGroupVariable])) {
|
|
$dataVariable = $appFields["APP_DATA"][$nextTaskGroupVariable];
|
|
$dataVariable = (is_array($dataVariable))? $dataVariable : trim($dataVariable);
|
|
|
|
if (!empty($dataVariable)) {
|
|
$appAssignSelfServiceValue = new AppAssignSelfServiceValue();
|
|
|
|
$appAssignSelfServiceValue->create($appFields["APP_UID"], $iNewDelIndex, array("PRO_UID" => $appFields["PRO_UID"], "TAS_UID" => $nextDel["TAS_UID"], "GRP_UID" => serialize($dataVariable)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Check if $taskNextDel is Script-Task
|
|
if (!is_null($taskNextDel) && $taskNextDel->getTasType() == "SCRIPT-TASK") {
|
|
//Get for $nextDel["TAS_UID"] your next Task
|
|
$currentDelegationAux = array_merge($currentDelegation, array("DEL_INDEX" => $iNewDelIndex, "TAS_UID" => $nextDel["TAS_UID"]));
|
|
$nextDelegationsAux = array();
|
|
|
|
$taskNextDelNextDelRouType = "";
|
|
$i = 0;
|
|
|
|
$arrayTaskNextDelNextDelegations = $this->prepareInformation(array(
|
|
"USER_UID" => $_SESSION["USER_LOGGED"],
|
|
"APP_UID" => $currentDelegation["APP_UID"],
|
|
"DEL_INDEX" => $iNewDelIndex
|
|
));
|
|
|
|
foreach ($arrayTaskNextDelNextDelegations as $key2 => $value2) {
|
|
$arrayTaskNextDelNextDel = $value2;
|
|
|
|
if($arrayTaskNextDelNextDel["NEXT_TASK"]["TAS_ASSIGN_TYPE"] == 'MULTIPLE_INSTANCE'){
|
|
$aUserAssigned = true;
|
|
if(!isset($arrayTaskNextDelNextDel["NEXT_TASK"]["USER_ASSIGNED"]["0"]["USR_UID"])){
|
|
throw new Exception(G::LoadTranslation("ID_NO_USERS"));
|
|
}
|
|
} else {
|
|
if (!isset($arrayTaskNextDelNextDel["NEXT_TASK"]["USER_ASSIGNED"]["USR_UID"])) {
|
|
throw new Exception(G::LoadTranslation("ID_NO_USERS"));
|
|
}
|
|
}
|
|
|
|
$rouPreType = "";
|
|
$rouPreTask = "";
|
|
$taskNextDelNextDelRouType = $arrayTaskNextDelNextDel["ROU_TYPE"];
|
|
|
|
if(isset($arrayTaskNextDelNextDel["NEXT_TASK"]["ROU_PREVIOUS_TYPE"]) && isset($arrayTaskNextDelNextDel["NEXT_TASK"]["ROU_PREVIOUS_TASK"])){
|
|
$rouPreType = $arrayTaskNextDelNextDel["NEXT_TASK"]["ROU_PREVIOUS_TYPE"];
|
|
$rouPreTask = $arrayTaskNextDelNextDel["NEXT_TASK"]["ROU_PREVIOUS_TASK"];
|
|
}
|
|
$nextDelegationsAux[++$i] = array(
|
|
"TAS_UID" => $arrayTaskNextDelNextDel["NEXT_TASK"]["TAS_UID"],
|
|
"USR_UID" => $arrayTaskNextDelNextDel["NEXT_TASK"]["USER_ASSIGNED"]["USR_UID"],
|
|
"TAS_ASSIGN_TYPE" => $arrayTaskNextDelNextDel["NEXT_TASK"]["TAS_ASSIGN_TYPE"],
|
|
"TAS_DEF_PROC_CODE" => $arrayTaskNextDelNextDel["NEXT_TASK"]["TAS_DEF_PROC_CODE"],
|
|
"DEL_PRIORITY" => "",
|
|
"TAS_PARENT" => $arrayTaskNextDelNextDel["NEXT_TASK"]["TAS_PARENT"],
|
|
"ROU_PREVIOUS_TYPE" => $rouPreType,
|
|
"ROU_PREVIOUS_TASK" => $rouPreTask
|
|
);
|
|
}
|
|
|
|
$currentDelegationAux["ROU_TYPE"] = $taskNextDelNextDelRouType;
|
|
|
|
$arrayNextDerivation[] = array("currentDelegation" => $currentDelegationAux, "nextDelegations" => $nextDelegationsAux);
|
|
}
|
|
} else {
|
|
//when the task doesnt generate a new AppDelegation
|
|
$iAppThreadIndex = $appFields['DEL_THREAD'];
|
|
|
|
$routeType = $currentDelegation["ROU_TYPE"];
|
|
$routeType = ($flagTaskIsMultipleInstance && $flagTaskAssignTypeIsMultipleInstance)? "SEC-JOIN" : $routeType;
|
|
|
|
switch ($routeType) {
|
|
case 'SEC-JOIN':
|
|
//Throw Events
|
|
$this->throwEventsBetweenElementOriginAndElementDest($currentDelegation["TAS_UID"], $nextDel["TAS_UID"], $appFields, $flagFirstIteration, false);
|
|
|
|
//Close thread
|
|
$this->case->closeAppThread( $currentDelegation['APP_UID'], $iAppThreadIndex );
|
|
break;
|
|
default:
|
|
if ($currentDelegation['TAS_ASSIGN_TYPE'] == 'STATIC_MI' || $currentDelegation['TAS_ASSIGN_TYPE'] == 'CANCEL_MI') {
|
|
$this->case->closeAppThread( $currentDelegation['APP_UID'], $iAppThreadIndex );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ($flagUpdateCounters) {
|
|
$this->derivateUpdateCounters($currentDelegation, $nextDel, $taskNextDel, $appFields, (isset($iNewDelIndex))? $iNewDelIndex : 0, (isset($aSP))? $aSP : null, $removeList);
|
|
}
|
|
|
|
$removeList = false;
|
|
$flagFirstIteration = false;
|
|
|
|
unset($aSP);
|
|
}
|
|
|
|
/* 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'] );
|
|
|
|
$flag = false;
|
|
|
|
//check if there is any paused thread
|
|
|
|
$existThreadPaused = false;
|
|
if (isset($arraySiblings['pause'])) {
|
|
if (!empty($arraySiblings['pause'])) {
|
|
$existThreadPaused = true;
|
|
}
|
|
}
|
|
|
|
if ($openThreads == 0 && !$existThreadPaused) {
|
|
//Close case
|
|
$appFields["APP_STATUS"] = "COMPLETED";
|
|
$appFields["APP_FINISH_DATE"] = "now";
|
|
$this->verifyIsCaseChild($currentDelegation["APP_UID"], $currentDelegation["DEL_INDEX"]);
|
|
$flag = true;
|
|
|
|
}
|
|
|
|
if (isset( $iNewDelIndex )) {
|
|
$appFields["DEL_INDEX"] = $iNewDelIndex;
|
|
$appFields["TAS_UID"] = $nextDel["TAS_UID"];
|
|
|
|
$flag = true;
|
|
}
|
|
|
|
if ($flag) {
|
|
//Start Block : UPDATES APPLICATION
|
|
$this->case->updateCase( $currentDelegation["APP_UID"], $appFields );
|
|
//End Block : UPDATES APPLICATION
|
|
}
|
|
|
|
//Start the next derivations (Script-Task)
|
|
if (!empty($arrayNextDerivation)) {
|
|
foreach ($arrayNextDerivation as $value) {
|
|
$this->derivate($value["currentDelegation"], $value["nextDelegations"]);
|
|
}
|
|
}
|
|
|
|
//Return
|
|
return $arrayDerivationResult;
|
|
}
|
|
|
|
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']) {
|
|
case 'CANCEL_MI':
|
|
case 'STATIC_MI':
|
|
// Create new delegation depending on the no of users in the group
|
|
$iNewAppThreadIndex = $appFields['DEL_THREAD'];
|
|
$this->case->closeAppThread( $currentDelegation['APP_UID'], $iAppThreadIndex );
|
|
|
|
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 );
|
|
|
|
$iNewThreadIndex = $this->case->newAppThread( $currentDelegation['APP_UID'], $iMIDelIndex, $iAppThreadIndex );
|
|
|
|
//Setting the del Index for Updating the AppThread delIndex
|
|
if ($key == 0) {
|
|
$iNewDelIndex = $iMIDelIndex - 1;
|
|
}
|
|
} //end foreach
|
|
break;
|
|
case 'BALANCED':
|
|
$this->setTasLastAssigned( $nextDel['TAS_UID'], $nextDel['USR_UID'] );
|
|
//No Break, need no execute the default ones....
|
|
default:
|
|
$delPrevious = 0;
|
|
if($this->flagControlMulInstance){
|
|
$criteriaMulti = new Criteria("workflow");
|
|
$criteriaMulti->addSelectColumn(AppDelegationPeer::DEL_PREVIOUS);
|
|
$criteriaMulti->add(AppDelegationPeer::TAS_UID, $currentDelegation['TAS_UID'], Criteria::EQUAL);
|
|
$criteriaMultiR = AppDelegationPeer::doSelectRS($criteriaMulti);
|
|
$criteriaMultiR->setFetchmode(ResultSet::FETCHMODE_ASSOC);
|
|
$criteriaMultiR->next();
|
|
$row = $criteriaMultiR->getRow();
|
|
$delPrevious = $row['DEL_PREVIOUS'];
|
|
}
|
|
// 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, $this->flagControl, $this->flagControlMulInstance, $delPrevious);
|
|
break;
|
|
}
|
|
|
|
$iAppThreadIndex = $appFields['DEL_THREAD'];
|
|
|
|
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 );
|
|
break;
|
|
default:
|
|
$this->case->updateAppThread( $currentDelegation['APP_UID'], $iAppThreadIndex, $iNewDelIndex );
|
|
break;
|
|
} //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, $appFields);
|
|
|
|
$taskNextDel = TaskPeer::retrieveByPK($aSP["TAS_UID"]); //Sub-Process
|
|
|
|
//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 = trim($sOriginField, " @#%?$=");
|
|
$sTargetField = trim($sTargetField, " @#%?$=");
|
|
|
|
$aNewFields[$sTargetField] = isset( $appFields['APP_DATA'][$sOriginField] ) ? $appFields['APP_DATA'][$sOriginField] : '';
|
|
}
|
|
|
|
$aOldFields['APP_DATA'] = array_merge( $aOldFields['APP_DATA'], $aNewFields );
|
|
$aOldFields['APP_STATUS'] = 'TO_DO';
|
|
|
|
$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' )
|
|
);
|
|
|
|
if ($aSP['SP_SYNCHRONOUS'] == 0) {
|
|
$aSubApplication['SA_STATUS'] = 'FINISHED';
|
|
$aSubApplication['SA_FINISH_DATE'] = $aSubApplication['SA_INIT_DATE'];
|
|
}
|
|
|
|
$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();
|
|
|
|
//Create record in table APP_ASSIGN_SELF_SERVICE_VALUE
|
|
if ($taskNextDel->getTasAssignType() == "SELF_SERVICE" && trim($taskNextDel->getTasGroupVariable()) != "") {
|
|
$nextTaskGroupVariable = trim($taskNextDel->getTasGroupVariable(), " @#");
|
|
|
|
if (isset($aOldFields["APP_DATA"][$nextTaskGroupVariable])) {
|
|
$dataVariable = $aOldFields["APP_DATA"][$nextTaskGroupVariable];
|
|
$dataVariable = (is_array($dataVariable))? $dataVariable : trim($dataVariable);
|
|
|
|
if (!empty($dataVariable)) {
|
|
$appAssignSelfServiceValue = new AppAssignSelfServiceValue();
|
|
|
|
$appAssignSelfServiceValue->create($aNewCase["APPLICATION"], $aNewCase["INDEX"], array("PRO_UID" => $aNewCase["PROCESS"], "TAS_UID" => $aSP["TAS_UID"], "GRP_UID" => serialize($dataVariable)));
|
|
}
|
|
}
|
|
}
|
|
|
|
//If not is SYNCHRONOUS derivate one more time
|
|
if ($aSP['SP_SYNCHRONOUS'] == 0) {
|
|
$this->case->setDelInitDate( $currentDelegation['APP_UID'], $iNewDelIndex );
|
|
$aDeriveTasks = $this->prepareInformation( array ('USER_UID' => -1,'APP_UID' => $currentDelegation['APP_UID'],'DEL_INDEX' => $iNewDelIndex
|
|
) );
|
|
|
|
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']
|
|
);
|
|
$openThreads = 0;
|
|
if ($currentDelegation2['ROU_TYPE'] == 'SEC-JOIN') {
|
|
$openThreads = $this->case->GetOpenThreads($currentDelegation['APP_UID']);
|
|
}
|
|
if ($openThreads == 0) {
|
|
$this->derivate($currentDelegation2, $nextDelegations2);
|
|
} else {
|
|
$oSubApplication = new SubApplication();
|
|
$aSubApplication['SA_STATUS'] = 'ACTIVE';
|
|
$oSubApplication->update($aSubApplication);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} //end switch
|
|
return $iNewDelIndex;
|
|
}
|
|
|
|
/* verifyIsCaseChild
|
|
*
|
|
* @param string $sApplicationUID
|
|
* @return void
|
|
*/
|
|
function verifyIsCaseChild ($sApplicationUID, $delIndex = 0)
|
|
{
|
|
//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 || $aSA['SA_STATUS'] == "ACTIVE") {
|
|
$appFields = $oCase->loadCase($sApplicationUID, $delIndex);
|
|
//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);
|
|
$sOriginField = str_replace('%', '', $sOriginField);
|
|
$sOriginField = str_replace('?', '', $sOriginField);
|
|
$sOriginField = str_replace('$', '', $sOriginField);
|
|
$sOriginField = str_replace('=', '', $sOriginField);
|
|
$sTargetField = str_replace('@', '', $sTargetField);
|
|
$sTargetField = str_replace('#', '', $sTargetField);
|
|
$sTargetField = str_replace('%', '', $sTargetField);
|
|
$sTargetField = str_replace('?', '', $sTargetField);
|
|
$sTargetField = str_replace('$', '', $sTargetField);
|
|
$sTargetField = str_replace('=', '', $sTargetField);
|
|
$aNewFields[$sTargetField] = isset($appFields['APP_DATA'][$sOriginField]) ? $appFields['APP_DATA'][$sOriginField] : '';
|
|
if (isset($aParentCase['APP_DATA'][$sTargetField . '_label'])) {
|
|
$aNewFields[$sTargetField . '_label'] = isset($appFields['APP_DATA'][$sOriginField . '_label']) ? $appFields['APP_DATA'][$sOriginField . '_label'] : '';
|
|
}
|
|
}
|
|
$aParentCase['APP_DATA'] = array_merge($aParentCase['APP_DATA'], $aNewFields);
|
|
$oCase->updateCase($aSA['APP_PARENT'], $aParentCase);
|
|
/*----------------------------------********---------------------------------*/
|
|
$inbox = new ListInbox();
|
|
$inbox->update($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']
|
|
);
|
|
if ($aDeriveTask['NEXT_TASK']['TAS_ASSIGN_TYPE'] == "MANUAL") {
|
|
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);
|
|
|
|
if ($delIndex > 0) {
|
|
// Send notifications - Start
|
|
$oUser = new Users();
|
|
$aUser = $oUser->load($appFields["CURRENT_USER_UID"]);
|
|
|
|
$sFromName = $aUser["USR_FIRSTNAME"] . " " . $aUser["USR_LASTNAME"] . ($aUser["USR_EMAIL"] != "" ? " <" . $aUser["USR_EMAIL"] . ">" : "");
|
|
|
|
try {
|
|
$oCase->sendNotifications($appFields["TAS_UID"],
|
|
$nextDelegations2,
|
|
$appFields["APP_DATA"],
|
|
$sApplicationUID,
|
|
$delIndex,
|
|
$sFromName);
|
|
|
|
} catch (Exception $e) {
|
|
G::SendTemporalMessage(G::loadTranslation("ID_NOTIFICATION_ERROR") . " - " . $e->getMessage(), "warning", "string", null, "100%");
|
|
}
|
|
// Send notifications - End
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* getDerivatedCases
|
|
* 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
|
|
*
|
|
*/
|
|
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 );
|
|
$oDataset->next();
|
|
$aRow = $oDataset->getRow();
|
|
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']
|
|
);
|
|
|
|
$oDataset->next();
|
|
$aRow = $oDataset->getRow();
|
|
}
|
|
}
|
|
|
|
return $derivation;
|
|
}
|
|
|
|
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) {
|
|
$aData[$aKey] = $userid;
|
|
}
|
|
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 '';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|