/**
* Start/Continue case by Timer-Event
*
* @param string $datetime Datetime (yyyy-mm-dd hh:ii:ss)
* @param bool $frontEnd Flag to represent the terminal front-end
*
* return void
*/
public function startContinueCaseByTimerEvent($datetime, $frontEnd = false)
{
try {
\G::LoadClass("wsBase");
//Set variables
$ws = new \wsBase();
$case = new \Cases();
$common = new \ProcessMaker\Util\Common();
$common->setFrontEnd($frontEnd);
list($year, $month, $day, $hour, $minute) = $this->getYearMonthDayHourMinuteSecondByDatetime($datetime);
$date = "{$year}-{$month}-{$day}";
$dateIni = "{$year}-{$month}-{$day} 00:00:00";
$dateEnd = "{$year}-{$month}-{$day} 23:59:59";
//Start Timer-Event (start new case) ///////////////////////////////////////////////////////////////////////
$common->frontEndShow("START");
$this->log("START-NEW-CASES", "Date \"{$datetime}\": Start new cases");
//Query
$criteria = $this->getTimerEventCriteria();
$criteria->addSelectColumn(\BpmnEventPeer::EVN_NAME);
$criteria->addSelectColumn(\ElementTaskRelationPeer::TAS_UID);
$arrayCondition = array();
$arrayCondition[] = array(\TimerEventPeer::PRJ_UID, \ProcessPeer::PRO_UID, \Criteria::EQUAL);
$criteria->addJoinMC($arrayCondition, \Criteria::INNER_JOIN);
$criteria->add(\ProcessPeer::PRO_STATUS, "ACTIVE", \Criteria::EQUAL);
$arrayCondition = array();
$arrayCondition[] = array(\TimerEventPeer::PRJ_UID, \ElementTaskRelationPeer::PRJ_UID, \Criteria::EQUAL);
$arrayCondition[] = array(\TimerEventPeer::EVN_UID, \ElementTaskRelationPeer::ELEMENT_UID, \Criteria::EQUAL);
$criteria->addJoinMC($arrayCondition, \Criteria::INNER_JOIN);
$criteria->add(\ElementTaskRelationPeer::ELEMENT_TYPE, "bpmnEvent", \Criteria::EQUAL);
$arrayCondition = array();
$arrayCondition[] = array(\ElementTaskRelationPeer::PRJ_UID, \TaskPeer::PRO_UID, \Criteria::EQUAL);
$arrayCondition[] = array(\ElementTaskRelationPeer::TAS_UID, \TaskPeer::TAS_UID, \Criteria::EQUAL);
$criteria->addJoinMC($arrayCondition, \Criteria::INNER_JOIN);
$criteria->add(\TaskPeer::TAS_TYPE, "START-TIMER-EVENT", \Criteria::EQUAL);
$arrayCondition = array();
$arrayCondition[] = array(\TimerEventPeer::PRJ_UID, \BpmnEventPeer::PRJ_UID, \Criteria::EQUAL);
$arrayCondition[] = array(\TimerEventPeer::EVN_UID, \BpmnEventPeer::EVN_UID, \Criteria::EQUAL);
$criteria->addJoinMC($arrayCondition, \Criteria::INNER_JOIN);
$criteria->add(\BpmnEventPeer::EVN_TYPE, "START", \Criteria::EQUAL);
$criteria->add(\BpmnEventPeer::EVN_MARKER, "TIMER", \Criteria::EQUAL);
$criteria->add(\TimerEventPeer::TMREVN_OPTION, array("HOURLY", "DAILY", "MONTHLY", "EVERY", "ONE-DATE-TIME"), \Criteria::IN);
$criteria->add(\TimerEventPeer::TMREVN_STATUS, "ACTIVE", \Criteria::EQUAL);
$criteria->add($criteria->getNewCriterion(\TimerEventPeer::TMREVN_NEXT_RUN_DATE, $dateIni, \Criteria::GREATER_EQUAL)->addAnd($criteria->getNewCriterion(\TimerEventPeer::TMREVN_NEXT_RUN_DATE, $dateEnd, \Criteria::LESS_EQUAL))->addOr($criteria->getNewCriterion(\TimerEventPeer::TMREVN_NEXT_RUN_DATE, $dateIni, \Criteria::LESS_THAN)));
$criteria->add($criteria->getNewCriterion(\TimerEventPeer::TMREVN_END_DATE, $date, \Criteria::GREATER_EQUAL)->addOr($criteria->getNewCriterion(\TimerEventPeer::TMREVN_END_DATE, null, \Criteria::EQUAL)));
$rsCriteria = \TimerEventPeer::doSelectRS($criteria);
$rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
$flagRecord = false;
while ($rsCriteria->next()) {
$row = $rsCriteria->getRow();
$row["TMREVN_CONFIGURATION_DATA"] = unserialize($row["TMREVN_CONFIGURATION_DATA"]);
//Set variables
$arrayTimerEventData = $row;
$bpmnEventName = $row["EVN_NAME"];
$taskUid = $row["TAS_UID"];
//Create the new case
$timerEventNextRunDate = $arrayTimerEventData["TMREVN_NEXT_RUN_DATE"];
$timerEventNextRunDateNew = "";
$flagCase = false;
if (strtotime($timerEventNextRunDate) < strtotime($dateIni)) {
$timerEventNextRunDateNew = $this->getNextRunDateByDataAndDatetime($arrayTimerEventData, $datetime);
//Generate new date for old TMREVN_NEXT_RUN_DATE
$flagCase = true;
//Create the old case
} else {
list(, , , $hourCase, $minuteCase) = $this->getYearMonthDayHourMinuteSecondByDatetime($timerEventNextRunDate);
if ((int) ($hour . $minute) <= (int) ($hourCase . $minuteCase)) {
$flagCase = $hourCase == $hour && $minuteCase == $minute;
} else {
$timerEventNextRunDateNew = $this->getNextRunDateByDataAndDatetime($arrayTimerEventData, $datetime);
//Generate new date for old TMREVN_NEXT_RUN_DATE
$flagCase = true;
//Create the old case
}
}
if ($flagCase) {
if ($flagRecord) {
$common->frontEndShow("TEXT", "");
}
if ($bpmnEventName != "") {
$common->frontEndShow("TEXT", "> Name Timer-Event: {$bpmnEventName}");
}
$common->frontEndShow("TEXT", "> Creating the new case...");
//Start new case
$result = $ws->newCase($arrayTimerEventData["PRJ_UID"], "", $taskUid, array());
$arrayResult = json_decode(json_encode($result), true);
if ($arrayResult["status_code"] == 0) {
$applicationUid = $arrayResult["caseId"];
$applicationNumber = $arrayResult["caseNumber"];
$common->frontEndShow("TEXT", " - OK case #{$applicationNumber} was created");
$common->frontEndShow("TEXT", "> Routing the case #{$applicationNumber}...");
$this->log("CREATED-NEW-CASE", "Case #{$applicationNumber} created, APP_UID: {$applicationUid}, PRO_UID: " . $arrayTimerEventData["PRJ_UID"]);
//Derivate new case
$result = $ws->derivateCase("", $applicationUid, 1);
$arrayResult = json_decode(json_encode($result), true);
if ($arrayResult["status_code"] == 0) {
$common->frontEndShow("TEXT", " - OK");
$this->log("ROUTED-NEW-CASE", "Case #{$applicationNumber} routed, APP_UID: {$applicationUid}, PRO_UID: " . $arrayTimerEventData["PRJ_UID"]);
} else {
$common->frontEndShow("TEXT", " - Failed: " . $arrayResult["message"]);
$this->log("ROUTED-NEW-CASE", "Failed: " . $arrayResult["message"] . ", Case: #{$applicationNumber}, APP_UID: {$applicationUid}, PRO_UID: " . $arrayTimerEventData["PRJ_UID"]);
}
} else {
$common->frontEndShow("TEXT", " - Failed: " . $arrayResult["message"]);
$this->log("CREATED-NEW-CASE", "Failed: " . $arrayResult["message"] . ", PRO_UID: " . $arrayTimerEventData["PRJ_UID"]);
}
//Update Timer-Event
$arrayData = array();
switch ($arrayTimerEventData["TMREVN_OPTION"]) {
case "HOURLY":
case "DAILY":
case "MONTHLY":
case "EVERY":
if ($timerEventNextRunDateNew == "") {
$timerEventNextRunDateNew = $this->getNextRunDateByDataAndDatetime($arrayTimerEventData, $timerEventNextRunDate, false);
}
if ($arrayTimerEventData["TMREVN_OPTION"] != "EVERY" && $arrayTimerEventData["TMREVN_END_DATE"] . "" != "" && strtotime($timerEventNextRunDateNew) > strtotime($arrayTimerEventData["TMREVN_END_DATE"] . " 23:59:59")) {
$arrayData["TMREVN_STATUS"] = "PROCESSED";
} else {
$arrayData["TMREVN_NEXT_RUN_DATE"] = $timerEventNextRunDateNew;
}
break;
case "ONE-DATE-TIME":
$arrayData["TMREVN_STATUS"] = "PROCESSED";
break;
}
$arrayData["TMREVN_LAST_RUN_DATE"] = $timerEventNextRunDate;
$arrayData["TMREVN_LAST_EXECUTION_DATE"] = date("Y-m-d H:i:s");
$result = $this->singleUpdate($arrayTimerEventData["TMREVN_UID"], $arrayData);
$flagRecord = true;
}
}
if (!$flagRecord) {
$common->frontEndShow("TEXT", "Not exists any record to start a new case, on date \"{$datetime}\"");
$this->log("NO-RECORDS", "Not exists any record to start a new case");
}
$common->frontEndShow("END");
$this->log("END-NEW-CASES", "Date \"{$datetime}\": End new cases");
//Intermediate Catch Timer-Event (continue the case) ///////////////////////////////////////////////////////
$this->log("START-CONTINUE-CASES", "Date \"{$datetime}\": Start continue the cases");
//Query
$criteriaMain = $this->getTimerEventCriteria();
$criteriaMain->addSelectColumn(\AppDelegationPeer::APP_UID);
$criteriaMain->addSelectColumn(\AppDelegationPeer::DEL_INDEX);
$criteriaMain->addSelectColumn(\AppDelegationPeer::DEL_DELEGATE_DATE);
$criteriaMain->addSelectColumn(\BpmnEventPeer::EVN_NAME);
$arrayCondition = array();
$arrayCondition[] = array(\AppDelegationPeer::PRO_UID, \ProcessPeer::PRO_UID, \Criteria::EQUAL);
$criteriaMain->addJoinMC($arrayCondition, \Criteria::INNER_JOIN);
$criteriaMain->add(\ProcessPeer::PRO_STATUS, "ACTIVE", \Criteria::EQUAL);
$arrayCondition = array();
$arrayCondition[] = array(\AppDelegationPeer::APP_UID, \ApplicationPeer::APP_UID, \Criteria::EQUAL);
$criteriaMain->addJoinMC($arrayCondition, \Criteria::INNER_JOIN);
$criteriaMain->add(\ApplicationPeer::APP_STATUS, "DRAFT", \Criteria::NOT_EQUAL);
$arrayCondition = array();
$arrayCondition[] = array(\AppDelegationPeer::PRO_UID, \TaskPeer::PRO_UID, \Criteria::EQUAL);
$arrayCondition[] = array(\AppDelegationPeer::TAS_UID, \TaskPeer::TAS_UID, \Criteria::EQUAL);
$criteriaMain->addJoinMC($arrayCondition, \Criteria::INNER_JOIN);
$criteriaMain->add(\TaskPeer::TAS_TYPE, "INTERMEDIATE-CATCH-TIMER-EVENT", \Criteria::EQUAL);
$arrayCondition = array();
$arrayCondition[] = array(\TaskPeer::PRO_UID, \ElementTaskRelationPeer::PRJ_UID, \Criteria::EQUAL);
$arrayCondition[] = array(\TaskPeer::TAS_UID, \ElementTaskRelationPeer::TAS_UID, \Criteria::EQUAL);
$criteriaMain->addJoinMC($arrayCondition, \Criteria::INNER_JOIN);
$criteriaMain->add(\ElementTaskRelationPeer::ELEMENT_TYPE, "bpmnEvent", \Criteria::EQUAL);
$arrayCondition = array();
$arrayCondition[] = array(\ElementTaskRelationPeer::PRJ_UID, \TimerEventPeer::PRJ_UID, \Criteria::EQUAL);
$arrayCondition[] = array(\ElementTaskRelationPeer::ELEMENT_UID, \TimerEventPeer::EVN_UID, \Criteria::EQUAL);
$criteriaMain->addJoinMC($arrayCondition, \Criteria::INNER_JOIN);
$arrayCondition = array();
$arrayCondition[] = array(\TimerEventPeer::PRJ_UID, \BpmnEventPeer::PRJ_UID, \Criteria::EQUAL);
$arrayCondition[] = array(\TimerEventPeer::EVN_UID, \BpmnEventPeer::EVN_UID, \Criteria::EQUAL);
$criteriaMain->addJoinMC($arrayCondition, \Criteria::INNER_JOIN);
$criteriaMain->add(\BpmnEventPeer::EVN_TYPE, "INTERMEDIATE", \Criteria::EQUAL);
$criteriaMain->add(\BpmnEventPeer::EVN_MARKER, "TIMER", \Criteria::EQUAL);
$criteriaMain->add(\TimerEventPeer::TMREVN_OPTION, array("WAIT-FOR", "WAIT-UNTIL-SPECIFIED-DATE-TIME"), \Criteria::IN);
$criteriaMain->add(\TimerEventPeer::TMREVN_STATUS, "ACTIVE", \Criteria::EQUAL);
$criteriaMain->add(\AppDelegationPeer::DEL_THREAD_STATUS, "OPEN", \Criteria::EQUAL);
$criteriaMain->add(\AppDelegationPeer::DEL_FINISH_DATE, null, \Criteria::ISNULL);
//Number records total
$criteriaCount = clone $criteriaMain;
$criteriaCount->clearSelectColumns();
$criteriaCount->addSelectColumn("COUNT(" . \AppDelegationPeer::APP_UID . ") AS NUM_REC");
$rsCriteriaCount = \AppDelegationPeer::doSelectRS($criteriaCount);
$rsCriteriaCount->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
$result = $rsCriteriaCount->next();
$row = $rsCriteriaCount->getRow();
$numRecTotal = $row["NUM_REC"];
//Query
$total = $numRecTotal;
$counter = 0;
$start = 0;
$limit = 1000;
$flagRecord = false;
do {
$flagNextRecord = false;
$criteria = clone $criteriaMain;
$criteria->setOffset($start);
$criteria->setLimit($limit);
$rsCriteria = \AppDelegationPeer::doSelectRS($criteria);
$rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
while ($rsCriteria->next()) {
if ($counter + 1 > $total) {
$flagNextRecord = false;
break;
}
$row = $rsCriteria->getRow();
$row["TMREVN_CONFIGURATION_DATA"] = unserialize($row["TMREVN_CONFIGURATION_DATA"]);
//Set variables
$arrayTimerEventData = $row;
$arrayApplicationData = $case->loadCase($row["APP_UID"]);
$applicationUid = $row["APP_UID"];
$applicationNumber = $arrayApplicationData["APP_NUMBER"];
$delIndex = $row["DEL_INDEX"];
$delDelegateDate = $row["DEL_DELEGATE_DATE"];
$bpmnEventName = $row["EVN_NAME"];
//Continue the case
$continueCaseDate = $delDelegateDate;
switch ($arrayTimerEventData["TMREVN_OPTION"]) {
case "WAIT-FOR":
if ($arrayTimerEventData["TMREVN_DAY"] . "" != "") {
$continueCaseDate = date("Y-m-d H:i:s", strtotime("{$continueCaseDate} +" . (int) $arrayTimerEventData["TMREVN_DAY"] . " days"));
}
if ($arrayTimerEventData["TMREVN_HOUR"] . "" != "") {
$continueCaseDate = date("Y-m-d H:i:s", strtotime("{$continueCaseDate} +" . (int) $arrayTimerEventData["TMREVN_HOUR"] . " hours"));
}
if ($arrayTimerEventData["TMREVN_MINUTE"] . "" != "") {
$continueCaseDate = date("Y-m-d H:i:s", strtotime("{$continueCaseDate} +" . (int) $arrayTimerEventData["TMREVN_MINUTE"] . " minutes"));
}
break;
case "WAIT-UNTIL-SPECIFIED-DATE-TIME":
$continueCaseDate = \G::replaceDataField($arrayTimerEventData["TMREVN_CONFIGURATION_DATA"], $arrayApplicationData["APP_DATA"]);
break;
}
$arrayContinueCaseDateData = $this->getYearMonthDayHourMinuteSecondByDatetime($continueCaseDate);
if (!empty($arrayContinueCaseDateData)) {
$flagCase = false;
if (strtotime($continueCaseDate) < strtotime($dateIni)) {
$flagCase = true;
//Continue the old case
} else {
$yearCase = $arrayContinueCaseDateData[0];
$monthCase = $arrayContinueCaseDateData[1];
$dayCase = $arrayContinueCaseDateData[2];
$hourCase = $arrayContinueCaseDateData[3];
$minuteCase = $arrayContinueCaseDateData[4];
if ("{$yearCase}-{$monthCase}-{$dayCase}" == "{$year}-{$month}-{$day}") {
if ((int) ($hour . $minute) <= (int) ($hourCase . $minuteCase)) {
$flagCase = $hourCase == $hour && $minuteCase == $minute;
} else {
$flagCase = true;
//Continue the old case
}
}
}
if ($flagCase) {
if ($flagRecord) {
$common->frontEndShow("TEXT", "");
}
if ($bpmnEventName != "") {
$common->frontEndShow("TEXT", "> Name Timer-Event: {$bpmnEventName}");
}
$common->frontEndShow("TEXT", "> Continue the case #{$applicationNumber}");
$common->frontEndShow("TEXT", "> Routing the case #{$applicationNumber}...");
//Continue the case
//Derivate case
$result = $ws->derivateCase("", $applicationUid, $delIndex);
$arrayResult = json_decode(json_encode($result), true);
if ($arrayResult["status_code"] == 0) {
$common->frontEndShow("TEXT", " - OK");
$this->log("CONTINUED-CASE", "Case #{$applicationNumber} continued, APP_UID: {$applicationUid}, PRO_UID: " . $arrayTimerEventData["PRJ_UID"]);
} else {
$common->frontEndShow("TEXT", " - Failed: " . $arrayResult["message"]);
$this->log("CONTINUED-CASE", "Failed: " . $arrayResult["message"] . ", Case: #{$applicationNumber}, APP_UID: {$applicationUid}, PRO_UID: " . $arrayTimerEventData["PRJ_UID"]);
}
$flagRecord = true;
}
} else {
$this->log("INVALID-CONTINUE-DATE", "Continue date: {$continueCaseDate}, Case: #{$applicationNumber}, APP_UID: {$applicationUid}, PRO_UID: " . $arrayTimerEventData["PRJ_UID"]);
}
$counter++;
$flagNextRecord = true;
}
$start = $start + $limit;
} while ($flagNextRecord);
if (!$flagRecord) {
$common->frontEndShow("TEXT", "Not exists any record to continue a case, on date \"{$datetime}\"");
$this->log("NO-RECORDS", "Not exists any record to continue a case");
}
$common->frontEndShow("END");
$this->log("END-CONTINUE-CASES", "Date \"{$datetime}\": End continue the cases");
} catch (\Exception $e) {
throw $e;
}
}
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;
}
/* Redirect to next step */
unset( $_SESSION['bNoShowSteps'] );
$aNextStep = $oCase->getNextStep( $_SESSION['PROCESS'], $_SESSION['APPLICATION'], $_SESSION['INDEX'], $_SESSION['STEP_POSITION'] );
$sPage = $aNextStep['PAGE'];
G::header( 'location: ' . $sPage );
} else {
//when the case have another user or current user doesn't have rights to this self-service,
//just view the case Resume
// Get DEL_INDEX
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(AppDelegationPeer::DEL_INDEX);
$criteria->add(AppDelegationPeer::APP_UID, $sAppUid);
$criteria->add(AppDelegationPeer::DEL_LAST_INDEX , 1);
$rs = AppDelegationPeer::doSelectRS($criteria);
$rs->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$rs->next();
$row = $rs->getRow();
$_SESSION['APPLICATION'] = $sAppUid;
if($_action=='search'){
$_SESSION['INDEX'] = $iDelIndex;
} else {
$_SESSION['INDEX'] = $row['DEL_INDEX'];
}
$_SESSION['PROCESS'] = $aFields['PRO_UID'];
$_SESSION['TASK'] = - 1;
//$Fields = $oCase->loadCase( $_SESSION['APPLICATION'], $_SESSION['INDEX'] );
if ($_action == 'jump') {
$Fields = $oCase->loadCase( $_SESSION['APPLICATION'], $_SESSION['INDEX'], 1);
/**
* get the case summary data
*
* @param string $httpData->appUid
* @param string $httpData->delIndex
* @return array containg the case summary data
*/
function getSummary($httpData)
{
$labels = array();
$form = new Form('cases/cases_Resume', PATH_XMLFORM, SYS_LANG);
G::LoadClass('case');
$case = new Cases();
foreach ($form->fields as $fieldName => $field) {
$labels[$fieldName] = $field->label;
}
if (isset($_SESSION['_applicationFields']) && $_SESSION['_processData']) {
$applicationFields = $_SESSION['_applicationFields'];
unset($_SESSION['_applicationFields']);
$processData = $_SESSION['_processData'];
unset($_SESSION['_processData']);
} else {
if ($httpData->action == 'sent') {
// Get the last valid delegation for participated list
$criteria = new Criteria();
$criteria->addSelectColumn(AppDelegationPeer::DEL_INDEX);
$criteria->add(AppDelegationPeer::APP_UID, $httpData->appUid);
$criteria->add(AppDelegationPeer::DEL_FINISH_DATE, null, Criteria::ISNULL);
$criteria->addDescendingOrderByColumn(AppDelegationPeer::DEL_INDEX);
if (AppDelegationPeer::doCount($criteria) > 0) {
$dataset = AppDelegationPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$dataset->next();
$row = $dataset->getRow();
$httpData->delIndex = $row['DEL_INDEX'];
}
}
$applicationFields = $case->loadCase($httpData->appUid, $httpData->delIndex);
$process = new Process();
$processData = $process->load($applicationFields['PRO_UID']);
}
$data = array();
$task = new Task();
$taskData = $task->load($applicationFields['TAS_UID']);
$currentUser = $applicationFields['CURRENT_USER'] != '' ? $applicationFields['CURRENT_USER'] : '******' . G::LoadTranslation('ID_UNASSIGNED') . ']';
$data[] = array('label' => $labels['PRO_TITLE'], 'value' => $processData['PRO_TITLE'], 'section' => $labels['TITLE1']);
$data[] = array('label' => $labels['TITLE'], 'value' => $applicationFields['TITLE'], 'section' => $labels['TITLE1']);
$data[] = array('label' => $labels['APP_NUMBER'], 'value' => $applicationFields['APP_NUMBER'], 'section' => $labels['TITLE1']);
$data[] = array('label' => $labels['STATUS'], 'value' => $applicationFields['STATUS'], 'section' => $labels['TITLE1']);
$data[] = array('label' => $labels['APP_UID'], 'value' => $applicationFields['APP_UID'], 'section' => $labels['TITLE1']);
$data[] = array('label' => $labels['CREATOR'], 'value' => $applicationFields['CREATOR'], 'section' => $labels['TITLE1']);
$data[] = array('label' => $labels['CREATE_DATE'], 'value' => $applicationFields['CREATE_DATE'], 'section' => $labels['TITLE1']);
$data[] = array('label' => $labels['UPDATE_DATE'], 'value' => $applicationFields['UPDATE_DATE'], 'section' => $labels['TITLE1']);
$data[] = array('label' => $labels['DESCRIPTION'], 'value' => $applicationFields['DESCRIPTION'], 'section' => $labels['TITLE1']);
// note added by krlos pacha carlos[at]colosa[dot]com
//getting this field if it doesn't exist. Related 7994 bug
$taskData['TAS_TITLE'] = array_key_exists('TAS_TITLE', $taskData) ? $taskData['TAS_TITLE'] : Content::Load("TAS_TITLE", "", $applicationFields['TAS_UID'], SYS_LANG);
$data[] = array('label' => $labels['TAS_TITLE'], 'value' => $taskData['TAS_TITLE'], 'section' => $labels['TITLE2']);
$data[] = array('label' => $labels['CURRENT_USER'], 'value' => $currentUser, 'section' => $labels['TITLE2']);
$data[] = array('label' => $labels['DEL_DELEGATE_DATE'], 'value' => $applicationFields['DEL_DELEGATE_DATE'], 'section' => $labels['TITLE2']);
$data[] = array('label' => $labels['DEL_INIT_DATE'], 'value' => $applicationFields['DEL_INIT_DATE'], 'section' => $labels['TITLE2']);
$data[] = array('label' => $labels['DEL_TASK_DUE_DATE'], 'value' => $applicationFields['DEL_TASK_DUE_DATE'], 'section' => $labels['TITLE2']);
$data[] = array('label' => $labels['DEL_FINISH_DATE'], 'value' => $applicationFields['DEL_FINISH_DATE'], 'section' => $labels['TITLE2']);
//$data[] = array('label'=>$labels['DYN_UID'] , 'value' => $processData['PRO_DYNAFORMS']['PROCESS'];, 'section'=>$labels['DYN_UID']);
return $data;
}
$_SESSION['INDEX'] = $iDelIndex;
$_SESSION['PROCESS'] = $aFields['PRO_UID'];
$_SESSION['TASK'] = -1;
$_SESSION['STEP_POSITION'] = 0;
require_once PATH_METHODS . 'cases' . PATH_SEP . 'cases_Resume.php';
exit;
}
/**
* these routine is to verify if the case was acceded from advaced search list
*/
if ($_action == 'search') {
//verify if the case is with teh current user
$c = new Criteria('workflow');
$c->add(AppDelegationPeer::APP_UID, $sAppUid);
$c->addDescendingOrderByColumn(AppDelegationPeer::DEL_INDEX);
$oDataset = AppDelegationPeer::doSelectRs($c);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset->next();
$aData = $oDataset->getRow();
if ($aData['USR_UID'] != $_SESSION['USER_LOGGED'] && $aData['USR_UID'] != "") {
//distinct "" for selfservice
//so we show just the resume
$_SESSION['alreadyDerivated'] = true;
//the case is paused show only the resume
$_SESSION['APPLICATION'] = $sAppUid;
$_SESSION['INDEX'] = $iDelIndex;
$_SESSION['PROCESS'] = $aFields['PRO_UID'];
$_SESSION['TASK'] = -1;
$_SESSION['STEP_POSITION'] = 0;
require_once PATH_METHODS . 'cases' . PATH_SEP . 'cases_Resume.php';
exit;
public function getLastDeleration($APP_UID)
{
$c = new Criteria('workflow');
$c->addSelectColumn(AppDelegationPeer::APP_UID);
$c->addSelectColumn(AppDelegationPeer::DEL_INDEX);
$c->addSelectColumn(AppDelegationPeer::DEL_DELEGATE_DATE);
$c->addSelectColumn(AppDelegationPeer::DEL_INIT_DATE);
$c->addSelectColumn(AppDelegationPeer::DEL_TASK_DUE_DATE);
$c->addSelectColumn(AppDelegationPeer::DEL_FINISH_DATE);
$c->addSelectColumn(AppDelegationPeer::DEL_DURATION);
$c->addSelectColumn(AppDelegationPeer::DEL_QUEUE_DURATION);
$c->addSelectColumn(AppDelegationPeer::DEL_DELAY_DURATION);
$c->addSelectColumn(AppDelegationPeer::DEL_STARTED);
$c->addSelectColumn(AppDelegationPeer::DEL_FINISHED);
$c->addSelectColumn(AppDelegationPeer::DEL_DELAYED);
$c->addSelectColumn(AppDelegationPeer::USR_UID);
$c->add(AppDelegationPeer::APP_UID, $APP_UID);
$c->addDescendingOrderByColumn(AppDelegationPeer::DEL_INDEX);
$rs = AppDelegationPeer::doSelectRS($c);
$rs->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$rs->next();
return $rs->getRow();
}
/**
* Patch for reports by The Answer (17-10-2k8)
*
*
* @name reportsPatch
*
* param
* @return void
*/
function reportsPatch()
{
require_once 'classes/model/AppDelegation.php';
$oCriteria = new Criteria('workflow');
$del = DBAdapter::getStringDelimiter();
$oCriteria->addSelectColumn(AppDelegationPeer::APP_UID);
$oCriteria->addSelectColumn(AppDelegationPeer::DEL_INDEX);
$oCriteria->addSelectColumn(AppDelegationPeer::TAS_UID);
$oCriteria->addSelectColumn(AppDelegationPeer::DEL_DELEGATE_DATE);
$oCriteria->addSelectColumn(AppDelegationPeer::DEL_INIT_DATE);
$oCriteria->addSelectColumn(AppDelegationPeer::DEL_FINISH_DATE);
$oCriteria->addSelectColumn(AppDelegationPeer::DEL_DURATION);
$oDataset = AppDelegationPeer::doSelectRS($oCriteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset->next();
while ($aRow = $oDataset->getRow()) {
$oAppDelegation = new AppDelegation();
$aData['APP_UID'] = $aRow['APP_UID'];
$aData['DEL_INDEX'] = $aRow['DEL_INDEX'];
$aData['DEL_DELEGATE_DATE'] = $aRow['DEL_DELEGATE_DATE'];
if ($aRow['DEL_INIT_DATE'] == NULL) {
$aData['DEL_INIT_DATE'] = $aRow['DEL_DELEGATE_DATE'];
} else {
$aData['DEL_INIT_DATE'] = $aRow['DEL_INIT_DATE'];
}
//$aData['DEL_FINISH_DATE']=$aRow['DEL_FINISH_DATE'];
if ($aRow['DEL_DURATION'] != 0) {
G::LoadClass('dates');
$oDates = new dates();
$aData['DEL_DURATION'] = $oDates->calculateDuration($aData['DEL_INIT_DATE'], $aRow['DEL_FINISH_DATE'], null, null, $aRow['TAS_UID']);
}
$oAppDelegation->update($aData);
$oDataset->next();
}
return;
}
public function isExistNextNotification($app_uid, $del_index)
{
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn(AppDelegationPeer::APP_UID);
$oCriteria->add(AppDelegationPeer::APP_UID, $app_uid);
$oCriteria->add(AppDelegationPeer::DEL_PREVIOUS, $del_index);
$oCriteria->add(AppDelegationPeer::DEL_FINISH_DATE, null, Criteria::ISNULL);
$oCriteria->setLimit(1);
//execute the query
$oDataset = AppDelegationPeer::doSelectRS($oCriteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
if ($oDataset->next()) {
return true;
} else {
return false;
}
}
$oUser = new Users();
$aUser = $oUser->load($_SESSION['USER_LOGGED']);
if (trim($aUser['USR_EMAIL']) == '') {
$aUser['USR_EMAIL'] = 'info@' . $_SERVER['HTTP_HOST'];
}
$sFromName = '"' . $aUser['USR_FIRSTNAME'] . ' ' . $aUser['USR_LASTNAME'] . '" <' . $aUser['USR_EMAIL'] . '>';
try {
$oCase->sendNotifications($_SESSION['TASK'], $_POST['form']['TASKS'], $appFields['APP_DATA'], $_SESSION['APPLICATION'], $_SESSION['INDEX'], $sFromName);
} catch (Exception $e) {
G::SendTemporalMessage(G::loadTranslation('ID_NOTIFICATION_ERROR') . ' - ' . $e->getMessage(), 'warning', 'string', null, '100%');
}
// Send notifications - End
// Events - Start
$oEvent = new Event();
$oEvent->closeAppEvents($_SESSION['PROCESS'], $_SESSION['APPLICATION'], $_SESSION['INDEX'], $_SESSION['TASK']);
$oCurrentAppDel = AppDelegationPeer::retrieveByPk($_SESSION['APPLICATION'], $_SESSION['INDEX'] + 1);
$multipleDelegation = false;
// check if there are multiple derivations
if (count($_POST['form']['TASKS']) > 1) {
$multipleDelegation = true;
}
// If the case has been delegated
if (isset($oCurrentAppDel)) {
// if there is just a single derivation the TASK_UID can be set by the delegation data
if (!$multipleDelegation) {
$aCurrentAppDel = $oCurrentAppDel->toArray(BasePeer::TYPE_FIELDNAME);
$oEvent->createAppEvents($aCurrentAppDel['PRO_UID'], $aCurrentAppDel['APP_UID'], $aCurrentAppDel['DEL_INDEX'], $aCurrentAppDel['TAS_UID']);
} else {
// else we need to check every task and create the events if it have any
foreach ($_POST['form']['TASKS'] as $taskDelegated) {
$aCurrentAppDel = $oCurrentAppDel->toArray(BasePeer::TYPE_FIELDNAME);
/**
*
* @method
*
* Redirects a case to any step in the current task. In order for the step to
* be executed, the specified step much exist and if it contains a condition,
* it must evaluate to true.
*
* @name PMFRedirectToStep
* @label PMF Redirect To Step
* @link http://wiki.processmaker.com/index.php/ProcessMaker_Functions#PMFRedirectToStep.28.29
*
* @param string(32) | $sApplicationUID | Case ID | The unique ID for a case,
* @param int | $iDelegation | Delegation index | The delegation index of a case.
* @param string(32) | $sStepType | Type of Step | The type of step, which can be "DYNAFORM", "INPUT_DOCUMENT" or "OUTPUT_DOCUMENT".
* @param string(32) | $sStepUid | Step ID | The unique ID for the step.
* @return none | $none | None | None
*
*/
function PMFRedirectToStep($sApplicationUID, $iDelegation, $sStepType, $sStepUid)
{
$g = new G();
$g->sessionVarSave();
$iDelegation = intval($iDelegation);
$_SESSION["APPLICATION"] = $sApplicationUID;
$_SESSION["INDEX"] = $iDelegation;
require_once 'classes/model/AppDelegation.php';
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn(AppDelegationPeer::TAS_UID);
$oCriteria->add(AppDelegationPeer::APP_UID, $sApplicationUID);
$oCriteria->add(AppDelegationPeer::DEL_INDEX, $iDelegation);
$oDataset = AppDelegationPeer::doSelectRS($oCriteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset->next();
global $oPMScript;
$aRow = $oDataset->getRow();
if ($aRow) {
require_once 'classes/model/Step.php';
$oStep = new Step();
$oTheStep = $oStep->loadByType($aRow['TAS_UID'], $sStepType, $sStepUid);
$bContinue = true;
G::LoadClass('case');
$oCase = new Cases();
$aFields = $oCase->loadCase($sApplicationUID);
if ($oTheStep->getStepCondition() != '') {
G::LoadClass('pmScript');
$pmScript = new PMScript();
$pmScript->setFields($aFields['APP_DATA']);
$pmScript->setScript($oTheStep->getStepCondition());
$bContinue = $pmScript->evaluate();
}
if ($bContinue) {
switch ($oTheStep->getStepTypeObj()) {
case 'DYNAFORM':
$sAction = 'EDIT';
break;
case 'OUTPUT_DOCUMENT':
$sAction = 'GENERATE';
break;
case 'INPUT_DOCUMENT':
$sAction = 'ATTACH';
break;
case 'EXTERNAL':
$sAction = 'EDIT';
break;
case 'MESSAGE':
$sAction = '';
break;
}
// save data
if (!is_null($oPMScript)) {
$aFields['APP_DATA'] = $oPMScript->aFields;
$oCase->updateCase($sApplicationUID, $aFields);
}
$g->sessionVarRestore();
G::header('Location: ' . 'cases_Step?TYPE=' . $sStepType . '&UID=' . $sStepUid . '&POSITION=' . $oTheStep->getStepPosition() . '&ACTION=' . $sAction);
die;
}
}
$g->sessionVarRestore();
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $appUid, $delIndex Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($appUid = null, $delIndex = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(AppDelegationPeer::APP_UID);
$criteria->addSelectColumn(AppDelegationPeer::DEL_INDEX);
$criteria->addSelectColumn(AppDelegationPeer::DEL_PREVIOUS);
$criteria->addSelectColumn(AppDelegationPeer::PRO_UID);
$criteria->addSelectColumn(AppDelegationPeer::TAS_UID);
$criteria->addSelectColumn(AppDelegationPeer::USR_UID);
$criteria->addSelectColumn(AppDelegationPeer::DEL_TYPE);
$criteria->addSelectColumn(AppDelegationPeer::DEL_THREAD);
$criteria->addSelectColumn(AppDelegationPeer::DEL_THREAD_STATUS);
$criteria->addSelectColumn(AppDelegationPeer::DEL_PRIORITY);
$criteria->addSelectColumn(AppDelegationPeer::DEL_DELEGATE_DATE);
$criteria->addSelectColumn(AppDelegationPeer::DEL_INIT_DATE);
$criteria->addSelectColumn(AppDelegationPeer::DEL_TASK_DUE_DATE);
$criteria->addSelectColumn(AppDelegationPeer::DEL_FINISH_DATE);
$criteria->addSelectColumn(AppDelegationPeer::DEL_DURATION);
$criteria->addSelectColumn(AppDelegationPeer::DEL_QUEUE_DURATION);
$criteria->addSelectColumn(AppDelegationPeer::DEL_DELAY_DURATION);
$criteria->addSelectColumn(AppDelegationPeer::DEL_STARTED);
$criteria->addSelectColumn(AppDelegationPeer::DEL_FINISHED);
$criteria->addSelectColumn(AppDelegationPeer::DEL_DELAYED);
$criteria->addSelectColumn(AppDelegationPeer::DEL_DATA);
$criteria->addSelectColumn(AppDelegationPeer::APP_OVERDUE_PERCENTAGE);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = AppDelegationPeer::retrieveByPK($appUid, $delIndex);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table AppDelegation ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Generate data
*
* return void
*/
public function generateData()
{
try {
G::LoadClass("case");
AppAssignSelfServiceValuePeer::doDeleteAll(); //Delete all records
//Generate data
$case = new Cases();
$criteria = new Criteria("workflow");
$criteria->addSelectColumn(AppDelegationPeer::APP_UID);
$criteria->addSelectColumn(AppDelegationPeer::DEL_INDEX);
$criteria->addSelectColumn(ApplicationPeer::APP_DATA);
$criteria->addSelectColumn(AppDelegationPeer::PRO_UID);
$criteria->addSelectColumn(TaskPeer::TAS_UID);
$criteria->addSelectColumn(TaskPeer::TAS_GROUP_VARIABLE);
$criteria->addJoin(AppDelegationPeer::APP_UID, ApplicationPeer::APP_UID, Criteria::LEFT_JOIN);
$criteria->addJoin(AppDelegationPeer::TAS_UID, TaskPeer::TAS_UID, Criteria::LEFT_JOIN);
$criteria->add(TaskPeer::TAS_ASSIGN_TYPE, "SELF_SERVICE", Criteria::EQUAL);
$criteria->add(TaskPeer::TAS_GROUP_VARIABLE, "", Criteria::NOT_EQUAL);
$criteria->add(AppDelegationPeer::USR_UID, "", Criteria::EQUAL);
$criteria->add(AppDelegationPeer::DEL_THREAD_STATUS, "OPEN", Criteria::EQUAL);
$rsCriteria = AppDelegationPeer::doSelectRS($criteria);
$rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($rsCriteria->next()) {
$row = $rsCriteria->getRow();
$applicationData = $case->unserializeData($row["APP_DATA"]);
$taskGroupVariable = trim($row["TAS_GROUP_VARIABLE"], " @#");
if ($taskGroupVariable != "" && isset($applicationData[$taskGroupVariable]) && trim($applicationData[$taskGroupVariable]) != "") {
$this->create($row["APP_UID"], $row["DEL_INDEX"], array("PRO_UID" => $row["PRO_UID"], "TAS_UID" => $row["TAS_UID"], "GRP_UID" => trim($applicationData[$taskGroupVariable])));
}
}
} catch (Exception $e) {
throw $e;
}
}
/**
* Catch Message-Events for the Cases
*
* @param bool $frontEnd Flag to represent progress bar
*
* @return void
*/
public function catchMessageEvent($frontEnd = false)
{
try {
\G::LoadClass("wsBase");
//Set variables
$ws = new \wsBase();
$case = new \Cases();
$common = new \ProcessMaker\Util\Common();
$common->setFrontEnd($frontEnd);
//Get data
$totalMessageEvent = 0;
$counterStartMessageEvent = 0;
$counterIntermediateCatchMessageEvent = 0;
$counter = 0;
$flagFirstTime = false;
$common->frontEndShow("START");
do {
$flagNextRecords = false;
$arrayMessageApplicationUnread = $this->getMessageApplications(array("messageApplicationStatus" => "UNREAD"), null, null, 0, 1000);
if (!$flagFirstTime) {
$totalMessageEvent = $arrayMessageApplicationUnread["total"];
$flagFirstTime = true;
}
foreach ($arrayMessageApplicationUnread["data"] as $value) {
if ($counter + 1 > $totalMessageEvent) {
$flagNextRecords = false;
break;
}
$arrayMessageApplicationData = $value;
$processUid = $arrayMessageApplicationData["PRJ_UID"];
$taskUid = $arrayMessageApplicationData["TAS_UID"];
$messageApplicationUid = $arrayMessageApplicationData["MSGAPP_UID"];
$messageApplicationCorrelation = $arrayMessageApplicationData["MSGAPP_CORRELATION"];
$messageEventDefinitionUserUid = $arrayMessageApplicationData["MSGED_USR_UID"];
$messageEventDefinitionCorrelation = $arrayMessageApplicationData["MSGED_CORRELATION"];
$arrayVariable = $this->mergeVariables($arrayMessageApplicationData["MSGED_VARIABLES"], $arrayMessageApplicationData["MSGAPP_VARIABLES"]);
$flagCatched = false;
switch ($arrayMessageApplicationData["EVN_TYPE"]) {
case "START":
if ($messageEventDefinitionCorrelation == $messageApplicationCorrelation && $messageEventDefinitionUserUid != "") {
//Start and derivate new Case
$result = $ws->newCase($processUid, $messageEventDefinitionUserUid, $taskUid, $arrayVariable);
$arrayResult = json_decode(json_encode($result), true);
if ($arrayResult["status_code"] == 0) {
$applicationUid = $arrayResult["caseId"];
$result = $ws->derivateCase($messageEventDefinitionUserUid, $applicationUid, 1);
$flagCatched = true;
//Counter
$counterStartMessageEvent++;
}
}
break;
case "INTERMEDIATE":
$criteria = new \Criteria("workflow");
$criteria->addSelectColumn(\AppDelegationPeer::APP_UID);
$criteria->addSelectColumn(\AppDelegationPeer::DEL_INDEX);
$criteria->addSelectColumn(\AppDelegationPeer::USR_UID);
$criteria->add(\AppDelegationPeer::PRO_UID, $processUid, \Criteria::EQUAL);
$criteria->add(\AppDelegationPeer::TAS_UID, $taskUid, \Criteria::EQUAL);
$criteria->add(\AppDelegationPeer::DEL_THREAD_STATUS, "OPEN", \Criteria::EQUAL);
$criteria->add(\AppDelegationPeer::DEL_FINISH_DATE, null, \Criteria::ISNULL);
$rsCriteria = \AppDelegationPeer::doSelectRS($criteria);
$rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
while ($rsCriteria->next()) {
$row = $rsCriteria->getRow();
$applicationUid = $row["APP_UID"];
$delIndex = $row["DEL_INDEX"];
$userUid = $row["USR_UID"];
$arrayApplicationData = $case->loadCase($applicationUid);
if (\G::replaceDataField($messageEventDefinitionCorrelation, $arrayApplicationData["APP_DATA"]) == $messageApplicationCorrelation) {
//"Unpause" and derivate Case
$arrayApplicationData["APP_DATA"] = array_merge($arrayApplicationData["APP_DATA"], $arrayVariable);
$arrayResult = $case->updateCase($applicationUid, $arrayApplicationData);
$result = $ws->derivateCase($userUid, $applicationUid, $delIndex);
$flagCatched = true;
}
}
//Counter
if ($flagCatched) {
$counterIntermediateCatchMessageEvent++;
}
break;
}
//Message-Application catch
if ($flagCatched) {
$result = $this->update($messageApplicationUid, array("MSGAPP_STATUS" => "READ"));
}
$counter++;
//Progress bar
$common->frontEndShow("BAR", "Message-Events (unread): " . $counter . "/" . $totalMessageEvent . " " . $common->progressBar($totalMessageEvent, $counter));
$flagNextRecords = true;
}
} while ($flagNextRecords);
$common->frontEndShow("TEXT", "Total Message-Events unread: " . $totalMessageEvent);
$common->frontEndShow("TEXT", "Total cases started: " . $counterStartMessageEvent);
$common->frontEndShow("TEXT", "Total cases continued: " . $counterIntermediateCatchMessageEvent);
$common->frontEndShow("TEXT", "Total Message-Events pending: " . ($totalMessageEvent - ($counterStartMessageEvent + $counterIntermediateCatchMessageEvent)));
$common->frontEndShow("END");
} catch (\Exception $e) {
throw $e;
}
}
/**
* Retrieve object using using composite pkey values.
* @param string $app_uid
* @param int $del_index
* @param Connection $con
* @return AppDelegation
*/
public static function retrieveByPK($app_uid, $del_index, $con = null)
{
if ($con === null) {
$con = Propel::getConnection(self::DATABASE_NAME);
}
$criteria = new Criteria();
$criteria->add(AppDelegationPeer::APP_UID, $app_uid);
$criteria->add(AppDelegationPeer::DEL_INDEX, $del_index);
$v = AppDelegationPeer::doSelect($criteria, $con);
return !empty($v) ? $v[0] : null;
}
/**
* Verify if not exists input Document in Steps
*
* @param string $applicationUid Unique id of Case
* @param string $delIndex Delegataion index
* @param string $appDocumentUid
*
* return void Throw exception if not exists input Document in Steps
*/
public function throwExceptionIfInputDocumentNotExistsInSteps($applicacionUid, $delIndex, $appDocumentUid)
{
try {
//Verify Case
$appDelegation = \AppDelegationPeer::retrieveByPK($applicacionUid, $delIndex);
if (is_null($appDelegation)) {
throw new \Exception(\G::LoadTranslation("ID_CASE_DEL_INDEX_DOES_NOT_EXIST", array("app_uid", $applicacionUid, "del_index", $delIndex)));
}
$taskUid = $appDelegation->getTasUid();
//Verify Steps
$criteria = new \Criteria("workflow");
$criteria->addSelectColumn(\AppDocumentPeer::DOC_UID);
$criteria->add(\AppDocumentPeer::APP_DOC_UID, $appDocumentUid, \Criteria::EQUAL);
$criteria->add(\AppDocumentPeer::APP_UID, $applicacionUid, \Criteria::EQUAL);
$criteria->add(\AppDocumentPeer::APP_DOC_TYPE, "INPUT", \Criteria::EQUAL);
$rsCriteria = \AppDocumentPeer::doSelectRS($criteria);
$rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
if ($rsCriteria->next()) {
$row = $rsCriteria->getRow();
$inputDocumentUid = $row["DOC_UID"];
$criteria = new \Criteria("workflow");
$criteria->addSelectColumn(\StepPeer::STEP_UID);
$criteria->add(\StepPeer::TAS_UID, $taskUid, \Criteria::EQUAL);
$criteria->add(\StepPeer::STEP_TYPE_OBJ, "INPUT_DOCUMENT", \Criteria::EQUAL);
$criteria->add(\StepPeer::STEP_UID_OBJ, $inputDocumentUid, \Criteria::EQUAL);
$rsCriteria = \StepPeer::doSelectRS($criteria);
$rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
if (!$rsCriteria->next()) {
throw new \Exception(\G::LoadTranslation("ID_CASES_INPUT_DOCUMENT_DOES_NOT_EXIST", array($appDocumentUid)));
}
}
} catch (\Exception $e) {
throw $e;
}
}
$oCriteria->add(AppDelegationPeer::TAS_UID, $aTasks, Criteria::IN);
$oCriteria->add($oCriteria->getNewCriterion(AppDelegationPeer::DEL_FINISH_DATE, null, Criteria::ISNULL)->addOr($oCriteria->getNewCriterion(AppDelegationPeer::DEL_FINISH_DATE, '')));
if (AppDelegationPeer::doCount($oCriteria) > 0) {
$oStage->color = '#FF0000';
} else {
$oCriteria = new Criteria('workflow');
$oCriteria->add(AppDelegationPeer::APP_UID, $_SESSION['APPLICATION']);
$oCriteria->add(AppDelegationPeer::TAS_UID, $aTasks, Criteria::IN);
$oCriteria->add(AppDelegationPeer::DEL_THREAD_STATUS, 'CLOSED');
if (AppDelegationPeer::doCount($oCriteria) > 0) {
$oStage->color = '#006633';
} else {
$oCriteria = new Criteria('workflow');
$oCriteria->add(AppDelegationPeer::APP_UID, $_SESSION['APPLICATION']);
$oCriteria->add(AppDelegationPeer::TAS_UID, $aTasks, Criteria::IN);
if (AppDelegationPeer::doCount($oCriteria) == 0) {
$oStage->color = '#939598';
}
}
}
}
$oSM->stages[] = $oStage;
$oDataset->next();
}
foreach ($oSM->stages as $iKey => $oStage) {
if (isset($oSM->stages[$iKey + 1])) {
$oDerivation = new stdclass();
$oDerivation->stage = $oSM->stages[$iKey + 1]->uid;
$oSM->stages[$iKey]->derivation->to = array($oDerivation);
$oSM->stages[$iKey]->derivation->type = 0;
}
public function getUsersParticipatedInCase($sAppUid)
{
$c = new Criteria('workflow');
$c->addSelectColumn(AppDelegationPeer::APP_UID);
$c->addSelectColumn(AppDelegationPeer::USR_UID);
$c->addSelectColumn(UsersPeer::USR_USERNAME);
$c->addSelectColumn(UsersPeer::USR_EMAIL);
$c->add(AppDelegationPeer::APP_UID, $sAppUid, CRITERIA::EQUAL);
$c->addJoin(AppDelegationPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
$rs = AppDelegationPeer::doSelectRS($c);
$rs->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$rows = array();
$rs->next();
while ($row = $rs->getRow()) {
$rows[$row['USR_UID']] = $row;
$rs->next();
}
$response['criteria'] = $c;
$response['array'] = $rows;
return $response;
}
/**
*
* @url GET /loadActionByEmail
*/
public function loadActionByEmail($params)
{
$criteria = new Criteria();
$criteria->addSelectColumn('COUNT(*)');
$criteria->addJoin(AbeConfigurationPeer::ABE_UID, AbeRequestsPeer::ABE_UID);
$criteria->addJoin(AppDelegationPeer::APP_UID, AbeRequestsPeer::APP_UID);
$criteria->addJoin(AppDelegationPeer::DEL_INDEX, AbeRequestsPeer::DEL_INDEX);
$result = AbeConfigurationPeer::doSelectRS($criteria);
$result->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$result->next();
$totalCount = $result->getRow();
$totalCount = $totalCount['COUNT(*)'];
$criteria = new Criteria();
$criteria->addSelectColumn(AbeConfigurationPeer::ABE_UID);
$criteria->addSelectColumn(AbeConfigurationPeer::PRO_UID);
$criteria->addSelectColumn(AbeConfigurationPeer::TAS_UID);
$criteria->addSelectColumn(AbeConfigurationPeer::ABE_UPDATE_DATE);
$criteria->addSelectColumn(AbeConfigurationPeer::ABE_TEMPLATE);
$criteria->addSelectColumn(AbeConfigurationPeer::ABE_ACTION_FIELD);
$criteria->addSelectColumn(AbeConfigurationPeer::DYN_UID);
$criteria->addSelectColumn(AbeRequestsPeer::ABE_REQ_UID);
$criteria->addSelectColumn(AbeRequestsPeer::APP_UID);
$criteria->addSelectColumn(AbeRequestsPeer::DEL_INDEX);
$criteria->addSelectColumn(AbeRequestsPeer::ABE_REQ_SENT_TO);
$criteria->addSelectColumn(AbeRequestsPeer::ABE_REQ_STATUS);
$criteria->addSelectColumn(AbeRequestsPeer::ABE_REQ_SUBJECT);
$criteria->addSelectColumn(AbeRequestsPeer::ABE_REQ_ANSWERED);
$criteria->addSelectColumn(AbeRequestsPeer::ABE_REQ_BODY);
$criteria->addSelectColumn(AbeRequestsPeer::ABE_REQ_DATE);
$criteria->addSelectColumn(ApplicationPeer::APP_NUMBER);
$criteria->addSelectColumn(AppDelegationPeer::DEL_PREVIOUS);
$criteria->addJoin(AbeConfigurationPeer::ABE_UID, AbeRequestsPeer::ABE_UID);
$criteria->addJoin(ApplicationPeer::APP_UID, AbeRequestsPeer::APP_UID);
$criteria->addJoin(AppDelegationPeer::APP_UID, AbeRequestsPeer::APP_UID);
$criteria->addJoin(AppDelegationPeer::DEL_INDEX, AbeRequestsPeer::DEL_INDEX);
$criteria->addDescendingOrderByColumn(AbeRequestsPeer::ABE_REQ_DATE);
$criteria->setLimit($_REQUEST['limit']);
$criteria->setOffset($_REQUEST['start']);
$result = AbeConfigurationPeer::doSelectRS($criteria);
$result->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$data = Array();
$arrayPro = Array();
$arrayTAS = Array();
$index = 0;
while ($result->next()) {
$data[] = $result->getRow();
$criteriaRes = new Criteria();
$criteriaRes->addSelectColumn(AbeResponsesPeer::ABE_RES_UID);
$criteriaRes->addSelectColumn(AbeResponsesPeer::ABE_RES_CLIENT_IP);
$criteriaRes->addSelectColumn(AbeResponsesPeer::ABE_RES_DATA);
$criteriaRes->addSelectColumn(AbeResponsesPeer::ABE_RES_STATUS);
$criteriaRes->addSelectColumn(AbeResponsesPeer::ABE_RES_MESSAGE);
$criteriaRes->add(AbeResponsesPeer::ABE_REQ_UID, $data[$index]['ABE_REQ_UID']);
$resultRes = AbeResponsesPeer::doSelectRS($criteriaRes);
$resultRes->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$resultRes->next();
$dataRes = Array();
if ($dataRes = $resultRes->getRow()) {
$data[$index]['ABE_RES_UID'] = $dataRes['ABE_RES_UID'];
$data[$index]['ABE_RES_CLIENT_IP'] = $dataRes['ABE_RES_CLIENT_IP'];
$data[$index]['ABE_RES_DATA'] = $dataRes['ABE_RES_DATA'];
$data[$index]['ABE_RES_STATUS'] = $dataRes['ABE_RES_STATUS'];
$data[$index]['ABE_RES_MESSAGE'] = $dataRes['ABE_RES_MESSAGE'];
} else {
$data[$index]['ABE_RES_UID'] = '';
$data[$index]['ABE_RES_CLIENT_IP'] = '';
$data[$index]['ABE_RES_DATA'] = '';
$data[$index]['ABE_RES_STATUS'] = '';
$data[$index]['ABE_RES_MESSAGE'] = '';
}
$criteriaRes = new Criteria();
$criteriaRes->addSelectColumn(AppDelegationPeer::USR_UID);
$criteriaRes->addSelectColumn(UsersPeer::USR_FIRSTNAME);
$criteriaRes->addSelectColumn(UsersPeer::USR_LASTNAME);
$criteria->addJoin(AppDelegationPeer::APP_UID, $data[$index]['APP_UID']);
$criteria->addJoin(AppDelegationPeer::DEL_INDEX, $data[$index]['DEL_PREVIOUS']);
$criteria->addJoin(AppDelegationPeer::USR_UID, UsersPeer::USR_UID);
$resultRes = AppDelegationPeer::doSelectRS($criteriaRes);
$resultRes->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$resultRes->next();
if ($dataRes = $resultRes->getRow()) {
$data[$index]['USER'] = $dataRes['USR_FIRSTNAME'] . ' ' . $dataRes['USR_LASTNAME'];
} else {
$data[$index]['USER'] = '';
}
$data[$index]['ABE_REQ_ANSWERED'] = ($data[$index]['ABE_REQ_ANSWERED'] == 1) ? 'YES' : 'NO';
$index++;
}
$response = array();
$response['totalCount'] = $totalCount;
$response['data'] = $data;
return $response;
}
public function getSelfServiceCasesByEvaluate($userUid)
{
$cases = array();
//check groups assigned to SelfService task
G::LoadClass('groups');
$group = new Groups();
$aGroups = $group->getActiveGroupsForAnUser($userUid);
$c = new Criteria();
$c->clearSelectColumns();
$c->addSelectColumn(TaskPeer::TAS_UID);
$c->addSelectColumn(TaskPeer::PRO_UID);
$c->addSelectColumn(TaskPeer::TAS_GROUP_VARIABLE);
$c->addJoin(TaskPeer::PRO_UID, ProcessPeer::PRO_UID, Criteria::LEFT_JOIN);
$c->addJoin(TaskPeer::TAS_UID, TaskUserPeer::TAS_UID, Criteria::LEFT_JOIN);
$c->add(ProcessPeer::PRO_STATUS, 'ACTIVE');
$c->add(TaskPeer::TAS_ASSIGN_TYPE, 'SELF_SERVICE');
$c->add(TaskPeer::TAS_GROUP_VARIABLE, '', Criteria::NOT_EQUAL);
$rs = TaskPeer::doSelectRS($c);
$rs->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$rs->next();
if ($rs->getRecordCount() > 0) {
if (!class_exists('Cases')) {
G::loadClass('case');
}
$caseInstance = new Cases();
while ($row = $rs->getRow()) {
$tasGroupVariable = str_replace(array('@', '#'), '', $row['TAS_GROUP_VARIABLE']);
$c2 = new Criteria();
$c2->clearSelectColumns();
$c2->addSelectColumn(AppDelegationPeer::APP_UID);
$c2->add(AppDelegationPeer::TAS_UID, $row['TAS_UID']);
$c2->add(AppDelegationPeer::USR_UID, '');
$c2->add(AppDelegationPeer::DEL_THREAD_STATUS, 'OPEN');
$rs2 = AppDelegationPeer::doSelectRS($c2);
$rs2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$rs2->next();
while ($row2 = $rs2->getRow()) {
$caseData = $caseInstance->LoadCase($row2['APP_UID']);
if (isset($caseData['APP_DATA'][$tasGroupVariable])) {
if (trim($caseData['APP_DATA'][$tasGroupVariable]) != '') {
if (in_array(trim($caseData['APP_DATA'][$tasGroupVariable]), $aGroups)) {
$cases[] = $row2['APP_UID'];
}
}
}
$rs2->next();
}
$rs->next();
}
}
return $cases;
}
/**
* Get all the application delegation records from database
*
* @param string $appUID
* Application identifier
* @return array delegation records
*/
public function getApplicationDelegationsIndex($appUID)
{
$delIndexes = array();
$c = new Criteria();
$c->addSelectColumn(AppDelegationPeer::DEL_INDEX);
$c->add(AppDelegationPeer::APP_UID, $appUID);
$rs = AppDelegationPeer::doSelectRS($c);
$rs->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$rs->next();
$row = $rs->getRow();
while (is_array($row)) {
$delIndexes[] = $row['DEL_INDEX'];
$rs->next();
$row = $rs->getRow();
}
return $delIndexes;
}
$criteria->addSelectColumn(AppDelayPeer::APP_UID);
$criteria->addSelectColumn(AppDelayPeer::APP_DEL_INDEX);
$criteria->add(AppDelayPeer::PRO_UID, $oData->pro_uid);
$criteria->add(AppDelayPeer::APP_TYPE, 'PAUSE');
$criteria->add(AppDelayPeer::APP_DISABLE_ACTION_DATE, null, Criteria::ISNULL);
$dataset = AppDelayPeer::doSelectRS($criteria);
if ($dataset->getRecordCount() > 0) {
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$dataset->next();
while ($row = $dataset->getRow()) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(AppDelegationPeer::TAS_UID);
$criteria->add(AppDelegationPeer::APP_UID, $row['APP_UID']);
$criteria->add(AppDelegationPeer::DEL_INDEX, $row['APP_DEL_INDEX']);
$criteria->add(AppDelegationPeer::TAS_UID, $oData->task_uid);
$casesNumRec += AppDelegationPeer::doCount($criteria);
$dataset->next();
}
}
}
$response = new stdclass();
$response->casesNumRec = $casesNumRec;
//$json = new Services_JSON();
$sOutput = Bootstrap::json_encode($response);
break;
case "verifyNameFile":
$response = array();
$status = "OK";
$filename = $_POST["filename"];
while ($dataset->next()) {
$row = $dataset->getRow();
if ($row['TU_RELATION'] == 1) {
//users
$dataUser = $user->load($row['USR_UID']);
if (array_search($dataUser['USR_EMAIL'], $userPermission) === false) {
$userPermission[] = $dataUser['USR_EMAIL'];
}
} else {
//Groups
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(UsersPeer::USR_EMAIL);
$criteria->addSelectColumn(UsersPeer::USR_UID);
$criteria->add(GroupUserPeer::GRP_UID, $row['USR_UID']);
$criteria->addJoin(GroupUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
$oDataset = AppDelegationPeer::doSelectRs($criteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($oDataset->next()) {
$aRow = $oDataset->getRow();
if (array_search($aRow['USR_EMAIL'], $userPermission) === false) {
$userPermission[] = $aRow['USR_EMAIL'];
}
}
}
}
$userPermission = array_unique($userPermission);
foreach ($userPermission as $key => $value) {
$pmDrive->setPermission($appData['APP_DRIVE_FOLDER_UID'], $value, 'user', 'writer');
$pmDrive->setPermission($fileIdDrive, $value);
}
}
/**
* reassign Case
*
* @param string sessionId : The session ID (which was obtained during login)
* @param string caseId : The case ID (which can be obtained with the caseList() function)
* @param string delIndex : The delegation index number of the case (which can be obtained with the caseList()
* function).
* @param string userIdSource : The user who is currently assigned the case.
* @param string userIdTarget : The target user who will be newly assigned to the case.
* @return $result will return an object
*/
public function reassignCase ($sessionId, $caseId, $delIndex, $userIdSource, $userIdTarget)
{
$g = new G();
try {
$g->sessionVarSave();
$_SESSION["APPLICATION"] = $caseId;
$_SESSION["INDEX"] = $delIndex;
$_SESSION["USER_LOGGED"] = $userIdSource;
if ($userIdTarget == $userIdSource) {
$result = new wsResponse( 30, G::loadTranslation( 'ID_TARGET_ORIGIN_USER_SAME' ) );
$g->sessionVarRestore();
return $result;
}
/**
* ****************( 1 )*****************
*/
$oCriteria = new Criteria( 'workflow' );
$oCriteria->add( UsersPeer::USR_STATUS, 'ACTIVE' );
$oCriteria->add( UsersPeer::USR_UID, $userIdSource );
$oDataset = UsersPeer::doSelectRS( $oCriteria );
$oDataset->setFetchmode( ResultSet::FETCHMODE_ASSOC );
$oDataset->next();
$aRow = $oDataset->getRow();
if (! is_array( $aRow )) {
$result = new wsResponse( 31, G::loadTranslation( 'ID_INVALID_ORIGIN_USER' ) );
$g->sessionVarRestore();
return $result;
}
/**
* ****************( 2 )*****************
*/
$oCase = new Cases();
$rows = $oCase->loadCase( $caseId );
if (! is_array( $aRow )) {
$result = new wsResponse( 32, G::loadTranslation( 'ID_CASE_NOT_OPEN' ) );
$g->sessionVarRestore();
return $result;
}
/**
* ****************( 3 )*****************
*/
$oCriteria = new Criteria( 'workflow' );
$aConditions = array ();
// $aConditions[] = array(AppDelegationPeer::USR_UID, TaskUserPeer::USR_UID);
// $aConditions[] = array(AppDelegationPeer::TAS_UID, TaskUserPeer::TAS_UID);
// $oCriteria->addJoinMC($aConditions, Criteria::LEFT_JOIN);
//$oCriteria->addJoin(AppDelegationPeer::USR_UID, TaskUserPeer::USR_UID, Criteria::LEFT_JOIN);
$oCriteria->add( AppDelegationPeer::APP_UID, $caseId );
$oCriteria->add( AppDelegationPeer::USR_UID, $userIdSource );
$oCriteria->add( AppDelegationPeer::DEL_INDEX, $delIndex );
$oCriteria->add( AppDelegationPeer::DEL_FINISH_DATE, null, Criteria::ISNULL );
$oDataset = AppDelegationPeer::doSelectRS( $oCriteria );
$oDataset->setFetchmode( ResultSet::FETCHMODE_ASSOC );
$oDataset->next();
$aRow = $oDataset->getRow();
if (! is_array( $aRow )) {
$result = new wsResponse( 33, G::loadTranslation( 'ID_INVALID_CASE_DELEGATION_INDEX' ) );
$g->sessionVarRestore();
return $result;
}
$tasUid = $aRow['TAS_UID'];
$derivation = new Derivation();
$userList = $derivation->getAllUsersFromAnyTask($tasUid, true);
if (! in_array( $userIdTarget, $userList )) {
$result = new wsResponse( 34, G::loadTranslation( 'ID_TARGET_USER_DOES_NOT_HAVE_RIGHTS' ) );
$g->sessionVarRestore();
return $result;
}
/**
* ****************( 4 )*****************
*/
$oCriteria = new Criteria( 'workflow' );
$oCriteria->add( UsersPeer::USR_STATUS, 'ACTIVE' );
$oCriteria->add( UsersPeer::USR_UID, $userIdTarget );
$oDataset = UsersPeer::doSelectRS( $oCriteria );
$oDataset->setFetchmode( ResultSet::FETCHMODE_ASSOC );
$oDataset->next();
$aRow = $oDataset->getRow();
if (! is_array( $aRow )) {
$result = new wsResponse( 35, G::loadTranslation( 'ID_TARGET_USER_DESTINATION_INVALID' ) );
$g->sessionVarRestore();
return $result;
}
/**
* ****************( 5 )*****************
*/
$var = $oCase->reassignCase( $caseId, $delIndex, $userIdSource, $userIdTarget );
if (! $var) {
$result = new wsResponse( 36, G::loadTranslation( 'ID_CASE_COULD_NOT_REASSIGNED' ) );
$g->sessionVarRestore();
return $result;
}
$result = new wsResponse( 0, G::loadTranslation( 'ID_COMMAND_EXECUTED_SUCCESSFULLY' ) );
$g->sessionVarRestore();
return $result;
} catch (Exception $e) {
$result[] = array ('guid' => $e->getMessage(),'name' => $e->getMessage()
);
$g->sessionVarRestore();
return $result;
}
}
$filters['sort'] = G::toUpper($filters['sort']);
$columnsList = $listpeer::getFieldNames(BasePeer::TYPE_FIELDNAME);
if (!in_array($filters['sort'], $columnsList)) {
$filters['sort'] = '';
}
$filters['dir'] = G::toUpper($filters['dir']);
if (!($filters['dir'] == 'DESC' || $filters['dir'] == 'ASC')) {
$filters['dir'] = 'DESC';
}
$result = $list->loadList($userUid, $filters, function (array $record) {
try {
if (isset($record["DEL_PREVIOUS_USR_UID"])) {
if ($record["DEL_PREVIOUS_USR_UID"] == "") {
$appDelegation = AppDelegationPeer::retrieveByPK($record["APP_UID"], $record["DEL_INDEX"]);
if (!is_null($appDelegation)) {
$appDelegationPrevious = AppDelegationPeer::retrieveByPK($record["APP_UID"], $appDelegation->getDelPrevious());
if (!is_null($appDelegationPrevious)) {
$taskPrevious = TaskPeer::retrieveByPK($appDelegationPrevious->getTasUid());
if (!is_null($taskPrevious)) {
switch ($taskPrevious->getTasType()) {
case "SCRIPT-TASK":
$record["DEL_PREVIOUS_USR_UID"] = $taskPrevious->getTasType();
break;
}
}
}
}
}
$record["PREVIOUS_USR_UID"] = $record["DEL_PREVIOUS_USR_UID"];
$record["PREVIOUS_USR_USERNAME"] = $record["DEL_PREVIOUS_USR_USERNAME"];
$record["PREVIOUS_USR_FIRSTNAME"] = $record["DEL_PREVIOUS_USR_FIRSTNAME"];
/**
* Populates the object using an array.
*
* This is particularly useful when populating an object from one of the
* request arrays (e.g. $_POST). This method goes through the column
* names, checking to see whether a matching key exists in populated
* array. If so the setByName() method is called for that column.
*
* You can specify the key type of the array by additionally passing one
* of the class type constants TYPE_PHPNAME, TYPE_COLNAME, TYPE_FIELDNAME,
* TYPE_NUM. The default key type is the column's phpname (e.g. 'authorId')
*
* @param array $arr An array to populate the object from.
* @param string $keyType The type of keys the array uses.
* @return void
*/
public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
{
$keys = AppDelegationPeer::getFieldNames($keyType);
if (array_key_exists($keys[0], $arr)) {
$this->setAppUid($arr[$keys[0]]);
}
if (array_key_exists($keys[1], $arr)) {
$this->setDelIndex($arr[$keys[1]]);
}
if (array_key_exists($keys[2], $arr)) {
$this->setDelPrevious($arr[$keys[2]]);
}
if (array_key_exists($keys[3], $arr)) {
$this->setDelLastIndex($arr[$keys[3]]);
}
if (array_key_exists($keys[4], $arr)) {
$this->setProUid($arr[$keys[4]]);
}
if (array_key_exists($keys[5], $arr)) {
$this->setTasUid($arr[$keys[5]]);
}
if (array_key_exists($keys[6], $arr)) {
$this->setUsrUid($arr[$keys[6]]);
}
if (array_key_exists($keys[7], $arr)) {
$this->setDelType($arr[$keys[7]]);
}
if (array_key_exists($keys[8], $arr)) {
$this->setDelThread($arr[$keys[8]]);
}
if (array_key_exists($keys[9], $arr)) {
$this->setDelThreadStatus($arr[$keys[9]]);
}
if (array_key_exists($keys[10], $arr)) {
$this->setDelPriority($arr[$keys[10]]);
}
if (array_key_exists($keys[11], $arr)) {
$this->setDelDelegateDate($arr[$keys[11]]);
}
if (array_key_exists($keys[12], $arr)) {
$this->setDelInitDate($arr[$keys[12]]);
}
if (array_key_exists($keys[13], $arr)) {
$this->setDelTaskDueDate($arr[$keys[13]]);
}
if (array_key_exists($keys[14], $arr)) {
$this->setDelFinishDate($arr[$keys[14]]);
}
if (array_key_exists($keys[15], $arr)) {
$this->setDelDuration($arr[$keys[15]]);
}
if (array_key_exists($keys[16], $arr)) {
$this->setDelQueueDuration($arr[$keys[16]]);
}
if (array_key_exists($keys[17], $arr)) {
$this->setDelDelayDuration($arr[$keys[17]]);
}
if (array_key_exists($keys[18], $arr)) {
$this->setDelStarted($arr[$keys[18]]);
}
if (array_key_exists($keys[19], $arr)) {
$this->setDelFinished($arr[$keys[19]]);
}
if (array_key_exists($keys[20], $arr)) {
$this->setDelDelayed($arr[$keys[20]]);
}
if (array_key_exists($keys[21], $arr)) {
$this->setDelData($arr[$keys[21]]);
}
if (array_key_exists($keys[22], $arr)) {
$this->setAppOverduePercentage($arr[$keys[22]]);
}
}
/**
* Verify if not exists OuputDocument in Steps
*
* @param string $applicationUid Unique id of Case
* @param string $delIndex Delegation index
* @param string $outDocUuid
*
* return void Throw exception if not exists OuputDocument in Steps
*/
public function throwExceptionIfOuputDocumentNotExistsInSteps($applicacionUid, $delIndex, $outputDocumentUid)
{
try {
//Verify data
$appDelegation = \AppDelegationPeer::retrieveByPK($applicacionUid, $delIndex);
$taskUid = $appDelegation->getTasUid();
$criteria = new \Criteria("workflow");
$criteria->addSelectColumn(\StepPeer::STEP_UID);
$criteria->add(\StepPeer::TAS_UID, $taskUid, \Criteria::EQUAL);
$criteria->add(\StepPeer::STEP_TYPE_OBJ, "OUTPUT_DOCUMENT", \Criteria::EQUAL);
$criteria->add(\StepPeer::STEP_UID_OBJ, $outputDocumentUid, \Criteria::EQUAL);
$rsCriteria = \StepPeer::doSelectRS($criteria);
$rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
if (!$rsCriteria->next()) {
throw new \Exception(\G::LoadTranslation("ID_CASES_OUTPUT_DOES_NOT_EXIST", array($outputDocumentUid)));
}
} catch (\Exception $e) {
throw $e;
}
}
$r->totalCount = $totalCount;
$r->dataFormat = $dateFormat;
echo Bootstrap::json_encode($r);
break;
case 'showGeneratedDocument':
//require_once 'classes/model/AppDocument.php';
//require_once 'classes/model/AppDelegation.php';
$oAppDocument = new AppDocument();
$aFields = $oAppDocument->load($_POST['APP_DOC_UID']);
require_once 'classes/model/OutputDocument.php';
$oOutputDocument = new OutputDocument();
$aOD = $oOutputDocument->load($aFields['DOC_UID']);
$oCriteria = new Criteria('workflow');
$oCriteria->add(AppDelegationPeer::APP_UID, $aFields['APP_UID']);
$oCriteria->add(AppDelegationPeer::DEL_INDEX, $aFields['DEL_INDEX']);
$oDataset = AppDelegationPeer::doSelectRS($oCriteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset->next();
$aRow = $oDataset->getRow();
$oTask = new Task();
$aTask = $oTask->load($aRow['TAS_UID']);
$aFields['ORIGIN'] = $aTask['TAS_TITLE'];
require_once 'classes/model/Users.php';
$oUser = new Users();
$aUser = $oUser->load($aFields['USR_UID']);
$aFields['CREATOR'] = $aUser['USR_FIRSTNAME'] . ' ' . $aUser['USR_LASTNAME'];
$aFields['VIEW'] = G::LoadTranslation('ID_OPEN');
$aFields['FILE1'] = 'cases_ShowOutputDocument?a=' . $aFields['APP_DOC_UID'] . '&ext=doc&random=' . rand();
$aFields['FILE2'] = 'cases_ShowOutputDocument?a=' . $aFields['APP_DOC_UID'] . '&ext=pdf&random=' . rand();
$G_PUBLISH = new Publisher();
$G_PUBLISH->AddContent('xmlform', 'xmlform', 'cases/cases_ViewAnyOutputDocument', '', G::array_merges($aOD, $aFields), '');
public function load($sProcessUID, $bView = false, $sApplicationUID = '', $iDelegation = 0, $sTask = '', $bCT = false)
{
try {
$oProcess = new Process();
$aRow = $oProcess->load($sProcessUID);
$oPM->title->label = strip_tags($aRow['PRO_TITLE']);
$oPM->title->position->x = $aRow['PRO_TITLE_X'];
$oPM->title->position->y = $aRow['PRO_TITLE_Y'];
$oPM->task = array();
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn(TaskPeer::PRO_UID);
$oCriteria->addSelectColumn(TaskPeer::TAS_UID);
$oCriteria->addSelectColumn(ContentPeer::CON_VALUE);
$oCriteria->addSelectColumn(TaskPeer::TAS_START);
$oCriteria->addSelectColumn(TaskPeer::TAS_POSX);
$oCriteria->addSelectColumn(TaskPeer::TAS_POSY);
$oCriteria->addSelectColumn(TaskPeer::TAS_COLOR);
$oCriteria->addSelectColumn(TaskPeer::TAS_TYPE);
$aConditions = array();
$aConditions[] = array(0 => TaskPeer::TAS_UID, 1 => ContentPeer::CON_ID);
$aConditions[] = array(0 => ContentPeer::CON_CATEGORY, 1 => DBAdapter::getStringDelimiter() . 'TAS_TITLE' . DBAdapter::getStringDelimiter());
$aConditions[] = array(0 => ContentPeer::CON_LANG, 1 => DBAdapter::getStringDelimiter() . SYS_LANG . DBAdapter::getStringDelimiter());
$oCriteria->addJoinMC($aConditions, Criteria::LEFT_JOIN);
$oCriteria->add(TaskPeer::PRO_UID, $sProcessUID);
$oDataset = TaskPeer::doSelectRS($oCriteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset->next();
while ($aRow1 = $oDataset->getRow()) {
$oTask = null;
$oTask->uid = $aRow1['TAS_UID'];
$oTask->task_type = $aRow1['TAS_TYPE'];
if ($aRow1['TAS_TYPE'] == 'NORMAL') {
if ($aRow1['CON_VALUE'] == "") {
//There is no Label in Current SYS_LANG language so try to find in English - by default
$oTask1 = new Task();
$aFields1 = $oTask1->load($oTask->uid);
$aRow1['CON_VALUE'] = $oTask1->getTasTitle();
}
$oTask->label = strip_tags($aRow1['CON_VALUE']);
} else {
$oCriteria = new Criteria('workflow');
$del = DBAdapter::getStringDelimiter();
$oCriteria->add(SubProcessPeer::PRO_PARENT, $aRow1['PRO_UID']);
$oCriteria->add(SubProcessPeer::TAS_PARENT, $aRow1['TAS_UID']);
$oCriteria->addAsColumn('TAS_TITLE', 'C1.CON_VALUE');
$oCriteria->addAlias("C1", 'CONTENT');
$tasTitleConds = array();
$tasTitleConds[] = array(SubProcessPeer::TAS_PARENT, 'C1.CON_ID');
$tasTitleConds[] = array('C1.CON_CATEGORY', $del . 'TAS_TITLE' . $del);
$tasTitleConds[] = array('C1.CON_LANG', $del . SYS_LANG . $del);
$oCriteria->addJoinMC($tasTitleConds, Criteria::LEFT_JOIN);
$oDatasetX = SubProcessPeer::doSelectRS($oCriteria);
$oDatasetX->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDatasetX->next();
$aRowx = $oDatasetX->getRow();
if ($oProcess->exists($aRowx['PRO_UID'])) {
//$aRowy = $oProcess->load($aRowx['PRO_UID']);
//$oTask->label = $aRowy['PRO_TITLE'];
$oTask->label = $aRowx['TAS_TITLE'];
} else {
$oTask->label = strip_tags($aRow1['CON_VALUE']);
}
}
$oTask->taskINI = strtolower($aRow1['TAS_START']) == 'true' ? true : false;
$oTask->position->x = (int) $aRow1['TAS_POSX'];
$oTask->position->y = (int) $aRow1['TAS_POSY'];
$oTask->derivation = null;
$oTask->derivation->to = array();
$oCriteria = new Criteria('workflow');
$oCriteria->add(RoutePeer::PRO_UID, $sProcessUID);
$oCriteria->add(RoutePeer::TAS_UID, $aRow1['TAS_UID']);
$oDataset2 = RoutePeer::doSelectRS($oCriteria);
$oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset2->next();
while ($aRow2 = $oDataset2->getRow()) {
switch ($aRow2['ROU_TYPE']) {
case 'SEQUENTIAL':
$aRow2['ROU_TYPE'] = 0;
break;
case 'SELECT':
$aRow2['ROU_TYPE'] = 1;
break;
case 'EVALUATE':
$aRow2['ROU_TYPE'] = 2;
break;
case 'PARALLEL':
$aRow2['ROU_TYPE'] = 3;
break;
case 'PARALLEL-BY-EVALUATION':
$aRow2['ROU_TYPE'] = 4;
break;
case 'SEC-JOIN':
$aRow2['ROU_TYPE'] = 5;
break;
case 'DISCRIMINATOR':
$aRow2['ROU_TYPE'] = 8;
break;
}
$oTo = null;
$oTo->task = $aRow2['ROU_NEXT_TASK'];
$oTo->condition = $aRow2['ROU_CONDITION'];
$oTo->executant = $aRow2['ROU_TO_LAST_USER'];
$oTo->optional = $aRow2['ROU_OPTIONAL'];
$oTask->derivation->type = $aRow2['ROU_TYPE'];
$oTask->derivation->to[] = $oTo;
$oDataset2->next();
}
if ($bCT) {
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn('COUNT(*) AS CANT');
$oCriteria->addSelectColumn('MIN(DEL_FINISH_DATE) AS FINISH');
$oCriteria->add(AppDelegationPeer::APP_UID, $sApplicationUID);
$oCriteria->add(AppDelegationPeer::TAS_UID, $aRow1['TAS_UID']);
$oDataset2 = AppDelegationPeer::doSelectRS($oCriteria);
$oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset2->next();
$aRow2 = $oDataset2->getRow();
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn('DEL_FINISH_DATE');
$oCriteria->add(AppDelegationPeer::APP_UID, $sApplicationUID);
$oCriteria->add(AppDelegationPeer::TAS_UID, $aRow1['TAS_UID']);
$oCriteria->add(AppDelegationPeer::DEL_FINISH_DATE, null);
$oDataset2 = AppDelegationPeer::doSelectRS($oCriteria);
$oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset2->next();
$aRow3 = $oDataset2->getRow();
if ($aRow3) {
$aRow2['FINISH'] = '';
}
/*
if (($aRow2['FINISH'] == null) && ($aRow1['TAS_UID'] == $sTask)) {
$oTask->color = '#FF0000';
} else {
if ($aRow2['CANT'] != 0) {
if ($aRow2['FINISH'] == null) {
//$oTask->color = '#FF9900';
$oTask->color = '#FF0000';
} else {
$oTask->color = '#006633';
}
} else {
$oTask->color = "#939598";
}
}
*/
if (empty($aRow2["FINISH"]) && $aRow1["TAS_UID"] == $sTask) {
$oTask->color = "#FF0000";
//Red
} else {
if (!empty($aRow2["FINISH"])) {
$oTask->color = "#006633";
//Green
} else {
if ($aRow2["CANT"] == 0 || $oTask->derivation->type != 5) {
$oTask->color = "#939598";
//Gray
} else {
//$oTask->color = "#FF9900"; //Yellow
$oTask->color = "#FF0000";
//Red
}
}
}
} else {
if ($bView && $sApplicationUID != '' && $iDelegation > 0 && $sTask != '') {
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn('COUNT(*) AS CANT');
$oCriteria->addSelectColumn('MIN(DEL_FINISH_DATE) AS FINISH');
$oCriteria->add(AppDelegationPeer::APP_UID, $sApplicationUID);
$oCriteria->add(AppDelegationPeer::TAS_UID, $aRow1['TAS_UID']);
$oDataset2 = AppDelegationPeer::doSelectRS($oCriteria);
$oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset2->next();
$aRow2 = $oDataset2->getRow();
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn('DEL_FINISH_DATE');
$oCriteria->add(AppDelegationPeer::APP_UID, $sApplicationUID);
$oCriteria->add(AppDelegationPeer::TAS_UID, $aRow1['TAS_UID']);
$oCriteria->add(AppDelegationPeer::DEL_FINISH_DATE, null);
$oDataset2 = AppDelegationPeer::doSelectRS($oCriteria);
$oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset2->next();
$aRow3 = $oDataset2->getRow();
if ($aRow3) {
$aRow2['FINISH'] = '';
}
/*
if (($aRow2['FINISH'] == null) && ($aRow1['TAS_UID'] == $sTask)) {
$oTask->color = '#FF0000';
} else {
if ($aRow2['CANT'] != 0) {
if ($aRow2['FINISH'] == null) {
$oTask->color = '#FF9900';
} else {
$oTask->color = '#006633';
}
} else {
$oTask->color = '#939598';
}
}
*/
if (empty($aRow2["FINISH"]) && $aRow1["TAS_UID"] == $sTask) {
$oTask->color = "#FF0000";
//Red
} else {
if (!empty($aRow2["FINISH"])) {
$oTask->color = "#006633";
//Green
} else {
if ($aRow2["CANT"] == 0 || $oTask->derivation->type != 5) {
$oTask->color = "#939598";
//Gray
} else {
$oTask->color = "#FF9900";
//Yellow
}
}
}
}
}
$msg = array();
G::LoadClass('derivation');
$Derivation = new Derivation();
$users = $Derivation->getAllUsersFromAnyTask($aRow1['TAS_UID']);
$sw_error = false;
if (count($users) == 0) {
$sw_error = true;
$msg[] = G::LoadTranslation('ID_NO_USERS');
}
G::LoadClass('ArrayPeer');
$stepsCriteria = $this->getStepsCriteria($aRow1['TAS_UID']);
$oDatasetSteps = ArrayBasePeer::doSelectRS($stepsCriteria);
$oDatasetSteps->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDatasetSteps->next();
$countDynaform = 0;
$countOutput = 0;
$countInput = 0;
$countExternal = 0;
while ($aRowSteps = $oDatasetSteps->getRow()) {
switch ($aRowSteps['STEP_TYPE_OBJ']) {
case 'DYNAFORM':
$countDynaform++;
break;
case 'INPUT_DOCUMENT':
$countInput++;
break;
case 'OUTPUT_DOCUMENT':
$countOutput++;
break;
case 'EXTERNAL':
$countExternal++;
break;
}
$oDatasetSteps->next();
}
$totalSteps = $countDynaform + $countInput + $countOutput + $countExternal;
if ($totalSteps == 0) {
$sw_error = true;
$msg[] = G::LoadTranslation('ID_TASK_NO_STEPS');
}
if ($sw_error) {
$oTask->statusIcons[] = array('label' => implode(",", $msg), 'icon' => '/images/alert.gif', 'message' => implode(", ", $msg), 'url' => '');
}
$oPM->task[] = $oTask;
$oDataset->next();
}
$oPM->executant[] = G::LoadTranslation('ID_RULES_AND_USER_GROUPS');
$oPM->executant[] = G::LoadTranslation('ID_ADD_USER_OF_TASK');
$oPM->tasExtra[0]->label = '-- ' . G::LoadTranslation('ID_END_OF_PROCESS') . ' --';
$oPM->tasExtra[0]->uid = 'end';
$oPM->tasExtra[1]->label = '-- ' . G::LoadTranslation('ID_TAREA_COLGANTE') . ' --';
$oPM->tasExtra[1]->uid = 'leaf';
$oPM->guide = array();
$oPM->text = array();
$oPM->statusIcons = array();
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn(SwimlanesElementsPeer::SWI_UID);
// $oCriteria->addSelectColumn ( ContentPeer::CON_VALUE );
$oCriteria->addAsColumn("CON_VALUE", "CASE WHEN CONTENT.CON_VALUE IS NULL THEN (SELECT DISTINCT MAX(A.CON_VALUE) FROM CONTENT A WHERE SWIMLANES_ELEMENTS.SWI_UID=A.CON_ID ) ELSE CONTENT.CON_VALUE END ");
$oCriteria->addSelectColumn(SwimlanesElementsPeer::SWI_TYPE);
$oCriteria->addSelectColumn(SwimlanesElementsPeer::SWI_X);
$oCriteria->addSelectColumn(SwimlanesElementsPeer::SWI_Y);
$aConditions = array();
$aConditions[] = array(0 => SwimlanesElementsPeer::SWI_UID, 1 => ContentPeer::CON_ID);
$aConditions[] = array(0 => ContentPeer::CON_CATEGORY, 1 => DBAdapter::getStringDelimiter() . 'SWI_TEXT' . DBAdapter::getStringDelimiter());
$aConditions[] = array(0 => ContentPeer::CON_LANG, 1 => DBAdapter::getStringDelimiter() . SYS_LANG . DBAdapter::getStringDelimiter());
$oCriteria->addJoinMC($aConditions, Criteria::LEFT_JOIN);
$oCriteria->add(SwimlanesElementsPeer::PRO_UID, $sProcessUID);
$oDataset = SwimlanesElementsPeer::doSelectRS($oCriteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset->next();
while ($aRow = $oDataset->getRow()) {
switch (strtolower($aRow['SWI_TYPE'])) {
case 'line':
$oGuide = null;
$oGuide->uid = $aRow['SWI_UID'];
$oGuide->position = $aRow['SWI_X'] > 0 ? $aRow['SWI_X'] : $aRow['SWI_Y'];
$oGuide->direction = $aRow['SWI_X'] > 0 ? 'vertical' : 'horizontal';
$oPM->guide[] = $oGuide;
break;
case 'text':
$oText = null;
$oText->uid = $aRow['SWI_UID'];
$oText->label = strip_tags($aRow['CON_VALUE'] != '' ? str_replace(chr(92), '\', str_replace('<', '<', $aRow['CON_VALUE'])) : '-');
// $oText->label = '->' . $aRow ['CON_VALUE'] . '<-' ;
$oText->position->x = $aRow['SWI_X'];
$oText->position->y = $aRow['SWI_Y'];
$oPM->text[] = $oText;
break;
}
$oDataset->next();
}
$oPM->derivation = array('Sequential', 'Evaluate (manual)', 'Evaluate (auto)', 'Parallel (fork)', 'Parallel by evaluation (fork)', 'Parallel (sequential join)', 'Parallel (sequential main join)');
//Load extended task properties from plugin. By JHL Jan 18, 2011
$oPluginRegistry =& PMPluginRegistry::getSingleton();
$activePluginsForTaskProperties = $oPluginRegistry->getTaskExtendedProperties();
$oPM->taskOptions = array();
foreach ($activePluginsForTaskProperties as $key => $taskPropertiesInfo) {
$taskOption['title'] = $taskPropertiesInfo->sName;
$taskOption['id'] = $taskPropertiesInfo->sNamespace . "--" . $taskPropertiesInfo->sName;
$oPM->taskOptions[] = $taskOption;
}
//$oJSON = new Services_JSON();
return Bootstrap::json_encode($oPM);
//$oJSON->encode( $oPM );
} catch (Exception $oError) {
throw $oError;
}
}
public function getValidateSelfService($data)
{
$paused = false;
$data = array_change_key_case($data, CASE_LOWER);
$sTaskUID = $data['act_uid'];
$caseType = isset($data['case_type']) ? $data['case_type'] == 'assigned' ? $data['case_type'] : 'unassigned' : 'unassigned';
$response = new \stdclass();
$oCriteria = new \Criteria();
$arrayCondition = array();
$arrayCondition[] = array(\AppDelegationPeer::APP_UID, \AppDelayPeer::APP_UID);
$arrayCondition[] = array(\AppDelegationPeer::DEL_INDEX, \AppDelayPeer::APP_DEL_INDEX);
$oCriteria->addJoinMC($arrayCondition, \Criteria::LEFT_JOIN);
$oCriteria->add(\AppDelegationPeer::TAS_UID, $sTaskUID);
$oCriteria->add(\AppDelayPeer::APP_DISABLE_ACTION_USER, "0");
$oResult = \AppDelegationPeer::doSelectOne($oCriteria);
if (!empty($oResult)) {
$paused = true;
}
$response->paused = $paused;
$oCriteria = new \Criteria();
$oCriteria->add(\AppDelegationPeer::DEL_THREAD_STATUS, "OPEN");
$oCriteria->add(\AppDelegationPeer::TAS_UID, $sTaskUID);
if ($caseType == 'unassigned') {
$oCriteria->add(\AppDelegationPeer::USR_UID, "", \Criteria::EQUAL);
}
$oApplication = \AppDelegationPeer::doSelectOne($oCriteria);
$response->result = true;
if (!empty($oApplication) || $paused) {
$response->result = false;
$response->message = G::LoadTranslation('ID_CURRENT_ASSING_TYPE_WITH_CASES');
}
return $response;
}
/**
* Verify if the current case is already routed.
*
* @param string $AppUid the uid of the application
* @return array $Fields the fields
*/
public function alreadyRouted ($appUid, $sDelIndex)
{
$c = new Criteria("workflow");
$c->clearSelectColumns();
$c->addSelectColumn(AppDelegationPeer::APP_UID);
$c->add(AppDelegationPeer::APP_UID, $appUid);
$c->add(AppDelegationPeer::DEL_INDEX, $sDelIndex);
$c->add(AppDelegationPeer::DEL_FINISH_DATE, null, Criteria::ISNOTNULL);
$result = AppDelegationPeer::doSelectRS($c);
$result->setFetchmode(ResultSet::FETCHMODE_ASSOC);
if($result->next()) {
return true;
} else {
return false;
}
}
