fernando/luos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ProcessMaker-MA "Definicion de clases para el Backend"

Browse Source 
- Se ha creado el archivo "ProcessBpmn.php", en donde se definen los metodos
  necesarios para el proceso (create, read, update, delete)
- Se ha creado el archivo "TaskBpmn.php", en donde se definen los metodos
  necesarios para el task (get/update properties, get steps/triggers/users)
This commit is contained in:
Victor Saisa Lopez
2013-11-04 12:31:19 -04:00
parent 98aa62dd75
commit 597ef2a7a0
2 changed files with 969 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

509
workflow/engine/businessModel/Process.php Normal file
View File

@@ -0,0 +1,509 @@
<?php
namespace BusinessModel;
class Process
{
/**
* Create Route
*
* @param string $processUid
* @param string $taskUid
* @param string $nextTaskUid
* @param string $type
* @param bool $delete
*
* return string Return UID of new Route
*
* @access public
*/
public function defineRoute($processUid, $taskUid, $nextTaskUid, $type, $delete = false)
{
//Copy of processmaker/workflow/engine/methods/processes/processes_Ajax.php //case 'saveNewPattern':
$processMap = new processMap();
if ($type != "SEQUENTIAL" && $type != "SEC-JOIN" && $type != "DISCRIMINATOR") {
if ($processMap->getNumberOfRoutes($processUid, $taskUid, $nextTaskUid, $type) > 0) {
//die();
throw (new Exception());
}
//unset($aRow);
}
if ($delete || $type == "SEQUENTIAL" || $type == "SEC-JOIN" || $type == "DISCRIMINATOR") {
//G::LoadClass("tasks");
$tasks = new Tasks();
$tasks->deleteAllRoutesOfTask($processUid, $taskUid);
$tasks->deleteAllGatewayOfTask($processUid, $taskUid);
}
return $processMap->saveNewPattern($processUid, $taskUid, $nextTaskUid, $type, $delete);
}
/**
* Create/Update Process
*
* @param string $option
* @param array $arrayDefineProcessData
*
* return array Return data array with new UID for each element
*
* @access public
*/
public function defineProcess($option, $arrayDefineProcessData)
{
if (!isset($arrayDefineProcessData["process"]) || count($arrayDefineProcessData["process"]) == 0) {
throw (new Exception("Process data do not exist"));
}
//Process
$process = new Process();
$arrayProcessData = $arrayDefineProcessData["process"];
unset($arrayProcessData["tasks"]);
unset($arrayProcessData["routes"]);
switch ($option) {
case "CREATE":
if (!isset($arrayProcessData["USR_UID"]) || trim($arrayProcessData["USR_UID"]) == "") {
throw (new Exception("User data do not exist"));
}
if (!isset($arrayProcessData["PRO_TITLE"]) || trim($arrayProcessData["PRO_TITLE"]) == "") {
throw (new Exception("Process title data do not exist"));
}
if (!isset($arrayProcessData["PRO_DESCRIPTION"])) {
throw (new Exception("Process description data do not exist"));
}
if (!isset($arrayProcessData["PRO_CATEGORY"])) {
throw (new Exception("Process category data do not exist"));
}
break;
case "UPDATE":
break;
}
if (isset($arrayProcessData["PRO_TITLE"])) {
$arrayProcessData["PRO_TITLE"] = trim($arrayProcessData["PRO_TITLE"]);
}
if (isset($arrayProcessData["PRO_DESCRIPTION"])) {
$arrayProcessData["PRO_DESCRIPTION"] = trim($arrayProcessData["PRO_DESCRIPTION"]);
}
if (isset($arrayProcessData["PRO_TITLE"]) && $process->existsByProTitle($arrayProcessData["PRO_TITLE"])) {
throw (new Exception(G::LoadTranslation("ID_PROCESSTITLE_ALREADY_EXISTS", SYS_LANG, array("PRO_TITLE" => $arrayProcessData["PRO_TITLE"]))));
}
$arrayProcessData["PRO_DYNAFORMS"] = array ();
$arrayProcessData["PRO_DYNAFORMS"]["PROCESS"] = (isset($arrayProcessData["PRO_SUMMARY_DYNAFORM"]))? $arrayProcessData["PRO_SUMMARY_DYNAFORM"] : "";
unset($arrayProcessData["PRO_SUMMARY_DYNAFORM"]);
switch ($option) {
case "CREATE":
$processUid = $process->create($arrayProcessData);
//Call plugins
//$arrayData = array(
// "PRO_UID" => $processUid,
// "PRO_TEMPLATE" => (isset($arrayProcessData["PRO_TEMPLATE"]) && $arrayProcessData["PRO_TEMPLATE"] != "")? $arrayProcessData["PRO_TEMPLATE"] : "",
// "PROCESSMAP" => $this //?
//);
//
//$oPluginRegistry = &PMPluginRegistry::getSingleton();
//$oPluginRegistry->executeTriggers(PM_NEW_PROCESS_SAVE, $arrayData);
break;
case "UPDATE":
$result = $process->update($arrayProcessData);
$processUid = $arrayProcessData["PRO_UID"];
break;
}
//Process - Save Calendar ID for this process
if (isset($arrayProcessData["PRO_CALENDAR"]) && $arrayProcessData["PRO_CALENDAR"] != "") {
$calendar = new Calendar();
$calendar->assignCalendarTo($processUid, $arrayProcessData["PRO_CALENDAR"], "PROCESS");
}
$uidAux = $arrayDefineProcessData["process"]["PRO_UID"];
$arrayDefineProcessData["process"]["PRO_UID"] = $processUid;
$arrayDefineProcessData["process"]["PRO_UID_OLD"] = $uidAux;
//Tasks
if (isset($arrayDefineProcessData["process"]["tasks"]) && count($arrayDefineProcessData["process"]["tasks"]) > 0) {
$arrayTaskData = $arrayDefineProcessData["process"]["tasks"];
foreach ($arrayTaskData as $index => $value) {
$t = $value;
$t["PRO_UID"] = $processUid;
$arrayData = $t;
$action = $arrayData["_action"];
unset($arrayData["_action"]);
switch ($action) {
case "CREATE":
//Create task
$arrayDataAux = array(
//"TAS_UID" => $arrayData["TAS_UID"],
"PRO_UID" => $arrayData["PRO_UID"],
"TAS_TITLE" => $arrayData["TAS_TITLE"],
"TAS_DESCRIPTION" => $arrayData["TAS_DESCRIPTION"],
"TAS_POSX" => $arrayData["TAS_POSX"],
"TAS_POSY" => $arrayData["TAS_POSY"],
"TAS_START" => $arrayData["TAS_START"]
);
$task = new Task();
$taskUid = $task->create($arrayDataAux);
$uidAux = $arrayDefineProcessData["process"]["tasks"][$index]["TAS_UID"];
$arrayDefineProcessData["process"]["tasks"][$index]["TAS_UID"] = $taskUid;
$arrayDefineProcessData["process"]["tasks"][$index]["TAS_UID_OLD"] = $uidAux;
//Update task properties
$task2 = new Task();
$arrayResult = $task2->updateProperties($taskUid, $processUid, $arrayData);
//Update array routes
if (isset($arrayDefineProcessData["process"]["routes"]) && count($arrayDefineProcessData["process"]["routes"]) > 0) {
$arrayDefineProcessData["process"]["routes"] = $this->routeUpdateTaskUidInArray($arrayDefineProcessData["process"]["routes"], $taskUid, $t["TAS_UID"]);
}
break;
case "UPDATE":
//Update task
$task = new Task();
$result = $task->update($arrayData);
//Update task properties
$task2 = new Task();
$arrayResult = $task2->updateProperties($arrayData["TAS_UID"], $processUid, $arrayData);
break;
case "DELETE":
$tasks = new Tasks();
$tasks->deleteTask($arrayData["TAS_UID"]);
break;
}
}
}
//Routes
if (isset($arrayDefineProcessData["process"]["routes"]) && count($arrayDefineProcessData["process"]["routes"]) > 0) {
$arrayRouteData = $arrayDefineProcessData["process"]["routes"];
foreach ($arrayRouteData as $index => $value) {
$r = $value;
$routeUid = $this->defineRoute( //***** New method
$processUid,
$r["TAS_UID"],
$r["ROU_NEXT_TASK"],
$r["ROU_TYPE"],
false
);
$uidAux = $arrayDefineProcessData["process"]["routes"][$index]["ROU_UID"];
$arrayDefineProcessData["process"]["routes"][$index]["ROU_UID"] = $routeUid;
$arrayDefineProcessData["process"]["routes"][$index]["ROU_UID_OLD"] = $uidAux;
}
}
return $arrayDefineProcessData;
}
/**
* Update UID in array
*
* @param array $arrayData
* @param string $taskUid
* @param string $taskUidOld
*
* return array Return data array with UID updated
*
* @access public
*/
public function routeUpdateTaskUidInArray($arrayData, $taskUid, $taskUidOld)
{
foreach ($arrayData as $index => $value) {
$r = $value;
if ($r["TAS_UID"] == $taskUidOld) {
$arrayData[$index]["TAS_UID"] = $taskUid;
}
if ($r["ROU_NEXT_TASK"] == $taskUidOld) {
$arrayData[$index]["ROU_NEXT_TASK"] = $taskUid;
}
}
return $arrayData;
}
/**
* Create Process
*
* @param string $userUid
* @param array $arrayDefineProcessData
*
* return array Return data array with new UID for each element
*
* @access public
*/
public function createProcess($userUid, $arrayDefineProcessData)
{
$arrayDefineProcessData["process"]["USR_UID"] = $userUid;
return $this->defineProcess("CREATE", $arrayDefineProcessData);
}
/**
* Load all Process
*
* @param array $arrayFilterData
* @param int $start
* @param int $limit
*
* return array Return data array with the Process
*
* @access public
*/
public function loadAllProcess($arrayFilterData = array(), $start = 0, $limit = 25)
{
//Copy of processmaker/workflow/engine/methods/processes/processesList.php
$process = new Process();
$memcache = &PMmemcached::getSingleton(SYS_SYS);
$memkey = "no memcache";
$memcacheUsed = "not used";
$totalCount = 0;
if (isset($arrayFilterData["category"]) && $arrayFilterData["category"] !== "<reset>") {
if (isset($arrayFilterData["processName"])) {
$proData = $process->getAllProcesses($start, $limit, $arrayFilterData["category"], $arrayFilterData["processName"]);
} else {
$proData = $process->getAllProcesses($start, $limit, $arrayFilterData["category"]);
}
} else {
if (isset($arrayFilterData["processName"])) {
$memkey = "processList-" . $start . "-" . $limit . "-" . $arrayFilterData["processName"];
$memcacheUsed = "yes";
if (($proData = $memcache->get($memkey)) === false) {
$proData = $process->getAllProcesses($start, $limit, null, $arrayFilterData["processName"]);
$memcache->set($memkey, $proData, PMmemcached::ONE_HOUR);
$memcacheUsed = "no";
}
} else {
$memkey = "processList-allProcesses-" . $start . "-" . $limit;
$memkeyTotal = $memkey . "-total";
$memcacheUsed = "yes";
if (($proData = $memcache->get($memkey)) === false || ($totalCount = $memcache->get($memkeyTotal)) === false) {
$proData = $process->getAllProcesses($start, $limit);
$totalCount = $process->getAllProcessesCount();
$memcache->set($memkey, $proData, PMmemcached::ONE_HOUR);
$memcache->set($memkeyTotal, $totalCount, PMmemcached::ONE_HOUR);
$memcacheUsed = "no";
}
}
}
$arrayData = array(
"memkey" => $memkey,
"memcache" => $memcacheUsed,
"data" => $proData,
"totalCount" => $totalCount
);
return $arrayData;
}
/**
* Load data of the Process
*
* @param string $processUid
*
* return array Return data array with data of the Process (attributes of the process, tasks and routes)
*
* @access public
*/
public function loadProcess($processUid)
{
$arrayDefineProcessData = array();
//Process
$process = new Process();
$arrayProcessData = $process->load($processUid);
$arrayDefineProcessData["process"] = array(
"PRO_UID" => $processUid,
"PRO_TITLE" => $arrayProcessData["PRO_TITLE"],
"PRO_DESCRIPTION" => $arrayProcessData["PRO_DESCRIPTION"],
"PRO_CATEGORY" => $arrayProcessData["PRO_CATEGORY"]
);
//Load data
$processMap = new processMap();
$arrayData = (array)(Bootstrap::json_decode($processMap->load($processUid)));
//Tasks & Routes
$arrayDefineProcessData["process"]["tasks"] = array();
$arrayDefineProcessData["process"]["routes"] = array();
if (isset($arrayData["task"]) && count($arrayData["task"]) > 0) {
foreach ($arrayData["task"] as $indext => $valuet) {
$t = (array)($valuet);
$taskUid = $t["uid"];
//Load task data
$task = new Task();
$arrayTaskData = $task->load($taskUid);
//Set task
$arrayDefineProcessData["process"]["tasks"][] = array(
"TAS_UID" => $taskUid,
"TAS_TITLE" => $arrayTaskData["TAS_TITLE"],
"TAS_DESCRIPTION" => $arrayTaskData["TAS_DESCRIPTION"],
"TAS_POSX" => $arrayTaskData["TAS_POSX"],
"TAS_POSY" => $arrayTaskData["TAS_POSY"],
"TAS_START" => $arrayTaskData["TAS_START"]
);
//Routes
if (isset($t["derivation"])) {
$t["derivation"] = (array)($t["derivation"]);
$type = "";
switch ($t["derivation"]["type"]) {
case 0:
$type = "SEQUENTIAL";
break;
case 1:
$type = "SELECT";
break;
case 2:
$type = "EVALUATE";
break;
case 3:
$type = "PARALLEL";
break;
case 4:
$type = "PARALLEL-BY-EVALUATION";
break;
case 5:
$type = "SEC-JOIN";
break;
case 8:
$type = "DISCRIMINATOR";
break;
}
foreach ($t["derivation"]["to"] as $indexr => $valuer) {
$r = (array)($valuer);
//Criteria
$criteria = new Criteria("workflow");
$criteria->addSelectColumn(RoutePeer::ROU_UID);
$criteria->add(RoutePeer::PRO_UID, $processUid, Criteria::EQUAL);
$criteria->add(RoutePeer::TAS_UID, $taskUid, Criteria::EQUAL);
$criteria->add(RoutePeer::ROU_NEXT_TASK, $r["task"], Criteria::EQUAL);
$rsCriteria = RoutePeer::doSelectRS($criteria);
$rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$rsCriteria->next();
$row = $rsCriteria->getRow();
$routeUid = $row["ROU_UID"];
//Set route
$arrayDefineProcessData["process"]["routes"][] = array(
"ROU_UID" => $routeUid,
"TAS_UID" => $taskUid,
"ROU_NEXT_TASK" => $r["task"],
"ROU_TYPE" => $type
);
}
}
}
}
return $arrayDefineProcessData;
}
/**
* Update Process
*
* @param string $processUid
* @param string $userUid
* @param array $arrayDefineProcessData
*
* return array
*
* @access public
*/
public function updateProcess($processUid, $userUid, $arrayDefineProcessData)
{
$arrayDefineProcessData["process"]["PRO_UID"] = $processUid;
$arrayDefineProcessData["process"]["USR_UID"] = $userUid;
return $this->defineProcess("UPDATE", $arrayDefineProcessData);
}
/**
* Delete Process
*
* @param string $processUid
* @param bool $checkCases
*
* return bool Return true, if is succesfully
*
* @access public
*/
public function deleteProcess($processUid, $checkCases = true)
{
if ($checkCases) {
$process = new Process();
$arrayCases = $process->getCasesCountInAllProcesses($processUid);
$sum = 0;
foreach ($arrayCases[$processUid] as $value) {
$sum = $sum + $value;
}
if ($sum > 0) {
throw (new Exception("You can't delete the process, because it has $sum cases"));
}
}
$processMap = new processMap();
return $processMap->deleteProcess($processUid);
}
}

460
workflow/engine/businessModel/Task.php Normal file
View File

@@ -0,0 +1,460 @@
<?php
namespace BusinessModel;
class Task
{
/**
* Get all properties of an Task
*
* @param string $taskUid
* @param bool $keyCaseToLower
*
* return array Return data array with all properties of an Task
*
* @access public
*/
public function getProperties($taskUid, $keyCaseToLower = false)
{
try {
G::LoadClass("configuration");
$task = new Task();
$arrayDataAux = $task->load($taskUid);
//$arrayDataAux["INDEX"] = 0;
//$arrayDataAux["IFORM"] = 1;
//$arrayDataAux["LANG"] = SYS_LANG;
//Assignment rules
switch ($arrayDataAux["TAS_ASSIGN_TYPE"]) {
case "SELF_SERVICE":
$arrayDataAux["TAS_ASSIGN_TYPE"] = (!empty($arrayDataAux["TAS_GROUP_VARIABLE"])) ? "SELF_SERVICE_EVALUATE" : $arrayDataAux["TAS_ASSIGN_TYPE"];
break;
}
//Timing control
//Load Calendar Information
$calendar = new Calendar();
$calendarInfo = $calendar->getCalendarFor("", "", $taskUid);
//If the function returns a DEFAULT calendar it means that this object doesn"t have assigned any calendar
$arrayDataAux["TAS_CALENDAR"] = ($calendarInfo["CALENDAR_APPLIED"] != "DEFAULT")? $calendarInfo["CALENDAR_UID"] : "";
//Notifications
$conf = new Configurations();
$conf->loadConfig($x, "TAS_EXTRA_PROPERTIES", $taskUid, "", "");
if (isset($conf->aConfig["TAS_DEF_MESSAGE_TYPE"]) && isset($conf->aConfig["TAS_DEF_MESSAGE_TYPE"])) {
$arrayDataAux["TAS_DEF_MESSAGE_TYPE"] = $conf->aConfig["TAS_DEF_MESSAGE_TYPE"];
$arrayDataAux["TAS_DEF_MESSAGE_TEMPLATE"] = $conf->aConfig["TAS_DEF_MESSAGE_TEMPLATE"];
}
//Set data
$arrayData = array();
$keyCase = ($keyCaseToLower)? CASE_LOWER : CASE_UPPER;
//Definition
$arrayData["DEFINITION"] = array_change_key_case(
array(
"TAS_PRIORITY_VARIABLE" => $arrayDataAux["TAS_PRIORITY_VARIABLE"],
"TAS_DERIVATION_SCREEN_TPL" => $arrayDataAux["TAS_DERIVATION_SCREEN_TPL"]
),
$keyCase
);
//Assignment Rules
$arrayData["ASSIGNMENT_RULES"] = array_change_key_case(
array(
"TAS_ASSIGN_TYPE" => $arrayDataAux["TAS_ASSIGN_TYPE"],
"TAS_ASSIGN_VARIABLE" => $arrayDataAux["TAS_ASSIGN_VARIABLE"],
"TAS_GROUP_VARIABLE" => $arrayDataAux["TAS_GROUP_VARIABLE"],
"TAS_SELFSERVICE_TIMEOUT" => $arrayDataAux["TAS_SELFSERVICE_TIMEOUT"],
"TAS_SELFSERVICE_TIME" => $arrayDataAux["TAS_SELFSERVICE_TIME"],
"TAS_SELFSERVICE_TIME_UNIT" => $arrayDataAux["TAS_SELFSERVICE_TIME_UNIT"],
"TAS_SELFSERVICE_TRIGGER_UID" => $arrayDataAux["TAS_SELFSERVICE_TRIGGER_UID"]
),
$keyCase
);
//Timing control
$arrayData["TIMING_CONTROL"] = array_change_key_case(
array(
"TAS_TRANSFER_FLY" => $arrayDataAux["TAS_TRANSFER_FLY"],
"TAS_DURATION" => $arrayDataAux["TAS_DURATION"],
"TAS_TIMEUNIT" => $arrayDataAux["TAS_TIMEUNIT"],
"TAS_TYPE_DAY" => $arrayDataAux["TAS_TYPE_DAY"],
"TAS_CALENDAR" => $arrayDataAux["TAS_CALENDAR"]
),
$keyCase
);
//Permissions
$arrayData["PERMISSIONS"] = array_change_key_case(
array(
"TAS_TYPE" => $arrayDataAux["TAS_TYPE"]
),
$keyCase
);
//Case Labels
$arrayData["CASE_LABELS"] = array_change_key_case(
array(
"TAS_DEF_TITLE" => $arrayDataAux["TAS_DEF_TITLE"],
"TAS_DEF_DESCRIPTION" => $arrayDataAux["TAS_DEF_DESCRIPTION"]
),
$keyCase
);
//Notifications
$arrayData["NOTIFICATIONS"] = array_change_key_case(
array(
"SEND_EMAIL" => $arrayDataAux["TAS_SEND_LAST_EMAIL"],
"TAS_DEF_SUBJECT_MESSAGE" => $arrayDataAux["TAS_DEF_SUBJECT_MESSAGE"],
"TAS_DEF_MESSAGE_TYPE" => $arrayDataAux["TAS_DEF_MESSAGE_TYPE"],
"TAS_DEF_MESSAGE" => $arrayDataAux["TAS_DEF_MESSAGE"],
"TAS_DEF_MESSAGE_TEMPLATE" => $arrayDataAux["TAS_DEF_MESSAGE_TEMPLATE"]
),
$keyCase
);
$arrayData = array_change_key_case($arrayData, $keyCase);
return $arrayData;
} catch (Exception $e) {
throw $e;
}
}
/**
* Update properties of an Task
*
* @param string $taskUid
* @param string $processUid
* @param array $arrayProperty
*
* return array
*
* @access public
*/
public function updateProperties($taskUid, $processUid, $arrayProperty)
{
//Copy of processmaker/workflow/engine/methods/tasks/tasks_Ajax.php //case "saveTaskData":
try {
$arrayProperty["TAS_UID"] = $taskUid;
$arrayProperty["PRO_UID"] = $processUid;
$task = new Task();
$aTaskInfo = $task->load($arrayProperty["TAS_UID"]);
$arrayResult = array();
/**
* routine to replace @amp@ by &
* that why the char "&" can't be passed by XmlHttpRequest directly
* @autor erik <erik@colosa.com>
*/
foreach ($arrayProperty as $k => $v) {
$arrayProperty[$k] = str_replace("@amp@", "&", $v);
}
if (isset($arrayProperty["SEND_EMAIL"])) {
$arrayProperty["TAS_SEND_LAST_EMAIL"] = ($arrayProperty["SEND_EMAIL"] == "TRUE")? "TRUE" : "FALSE";
} else {
//$aTaskInfo = $task->load($arrayProperty["TAS_UID"]);
$arrayProperty["TAS_SEND_LAST_EMAIL"] = (is_null($aTaskInfo["TAS_SEND_LAST_EMAIL"]))? "FALSE" : $aTaskInfo["TAS_SEND_LAST_EMAIL"];
}
//Additional configuration
if (isset($arrayProperty["TAS_DEF_MESSAGE_TYPE"]) && isset($arrayProperty["TAS_DEF_MESSAGE_TEMPLATE"])) {
G::LoadClass("configuration");
$oConf = new Configurations();
$oConf->aConfig = array("TAS_DEF_MESSAGE_TYPE" => $arrayProperty["TAS_DEF_MESSAGE_TYPE"], "TAS_DEF_MESSAGE_TEMPLATE" => $arrayProperty["TAS_DEF_MESSAGE_TEMPLATE"]);
$oConf->saveConfig("TAS_EXTRA_PROPERTIES", $arrayProperty["TAS_UID"], "", "");
unset($arrayProperty["TAS_DEF_MESSAGE_TYPE"]);
unset($arrayProperty["TAS_DEF_MESSAGE_TEMPLATE"]);
}
//Validating TAS_ASSIGN_VARIABLE value
if (!isset($arrayProperty["TAS_ASSIGN_TYPE"])) {
$derivateType = $task->kgetassigType($arrayProperty["PRO_UID"], $arrayProperty["TAS_UID"]);
if (is_null($derivateType)) {
$arrayProperty["TAS_ASSIGN_TYPE"] = "BALANCED";
} else {
$arrayProperty["TAS_ASSIGN_TYPE"] = $derivateType["TAS_ASSIGN_TYPE"];
}
}
if ($arrayProperty["TAS_ASSIGN_TYPE"] == "SELF_SERVICE_EVALUATE") {
$arrayProperty["TAS_ASSIGN_TYPE"] = "SELF_SERVICE";
if (trim($arrayProperty["TAS_GROUP_VARIABLE"]) == "") {
$arrayProperty["TAS_GROUP_VARIABLE"] = "@@SYS_GROUP_TO_BE_ASSIGNED";
}
} else {
$arrayProperty["TAS_GROUP_VARIABLE"] = "";
}
$result = $task->update($arrayProperty);
$arrayResult["status"] = "OK";
if ($result == 3) {
$arrayResult["status"] = "CRONCL";
}
return $arrayResult;
} catch (Exception $e) {
throw $e;
}
}
/**
* Get available steps of an Task
*
* @param string $taskUid
* @param string $processUid
* @param bool $keyCaseToLower
* @param int $start
* @param int $limit
*
* return array
*
* @access public
*/
public function getStepsList($taskUid, $processUid, $keyCaseToLower = false, $start = 0, $limit = 25)
{
try {
G::LoadClass("BasePeer");
$arrayData = array();
$keyCase = ($keyCaseToLower)? CASE_LOWER : CASE_UPPER;
//Criteria
$processMap = new ProcessMap();
$criteria = $processMap->getAvailableBBCriteria($processUid, $taskUid);
if ($criteria->getDbName() == "dbarray") {
$rsCriteria = ArrayBasePeer::doSelectRS($criteria);
} else {
$rsCriteria = GulliverBasePeer::doSelectRS($criteria);
}
$rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($rsCriteria->next()) {
$row = $rsCriteria->getRow();
$arrayData[] = array_change_key_case($row, $keyCase);
}
return array_change_key_case(
array("NUM_RECORDS" => count($arrayData), "DATA" => array_slice($arrayData, $start, $limit)),
$keyCase
);
} catch (Exception $e) {
throw $e;
}
}
/**
* Get all steps of the Task
*
* @param string $taskUid
* @param bool $keyCaseToLower
*
* return array
*
* @access public
*/
public function getSteps($taskUid, $keyCaseToLower = false)
{
try {
G::LoadClass("BasePeer");
$arrayData = array();
$keyCase = ($keyCaseToLower)? CASE_LOWER : CASE_UPPER;
//Criteria
$processMap = new ProcessMap();
$criteria = $processMap->getStepsCriteria($taskUid);
if ($criteria->getDbName() == "dbarray") {
$rsCriteria = ArrayBasePeer::doSelectRS($criteria);
} else {
$rsCriteria = GulliverBasePeer::doSelectRS($criteria);
}
$rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($rsCriteria->next()) {
$row = $rsCriteria->getRow();
$arrayData[] = array_change_key_case($row, $keyCase);
}
return $arrayData;
} catch (Exception $e) {
throw $e;
}
}
/**
* Get all triggers of the Task
*
* @param string $taskUid
* @param bool $keyCaseToLower
*
* return array
*
* @access public
*/
public function getTriggers($taskUid, $keyCaseToLower = false)
{
try {
G::LoadClass("BasePeer");
$arrayData = array();
$keyCase = ($keyCaseToLower)? CASE_LOWER : CASE_UPPER;
$arrayTriggerType1 = array(
"BEFORE" => "BEFORE",
"AFTER" => "AFTER"
);
$arrayTriggerType2 = array(
"BEFORE_ASSIGNMENT" => "BEFORE",
"BEFORE_ROUTING" => "BEFORE",
"AFTER_ROUTING" => "AFTER"
);
$processMap = new ProcessMap();
$stepTgr = new StepTrigger();
$arraySteps = $this->getSteps($taskUid);
$n = count($arraySteps) + 1;
$arraySteps[] = array(
"STEP_UID" => "",
"STEP_TITLE" => G::LoadTranslation("ID_ASSIGN_TASK"),
"STEP_TYPE_OBJ" => "",
"STEP_MODE" => "",
"STEP_CONDITION" => "",
"STEP_POSITION" => $n
);
foreach ($arraySteps as $index1 => $value1) {
$step = $value1;
$stepUid = $step["STEP_UID"];
//Set data
$arrayDataAux1 = array();
$arrayDataAux1["STEP_UID"] = $stepUid;
$arrayTriggerType = ($stepUid != "")? $arrayTriggerType1 : $arrayTriggerType2;
foreach ($arrayTriggerType as $index2 => $value2) {
$triggerType = $index2;
$type = $value2;
switch ($triggerType) {
case "BEFORE_ASSIGNMENT":
$stepUid = "-1";
break;
case "BEFORE_ROUTING":
$stepUid = "-2";
break;
case "AFTER_ROUTING":
$stepUid = "-2";
break;
}
$stepTgr->orderPosition($stepUid, $taskUid, $type);
$arrayDataAux2 = array();
//Criteria
$criteria = $processMap->getStepTriggersCriteria($stepUid, $taskUid, $type);
if ($criteria->getDbName() == "dbarray") {
$rsCriteria = ArrayBasePeer::doSelectRS($criteria);
} else {
$rsCriteria = GulliverBasePeer::doSelectRS($criteria);
}
$rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($rsCriteria->next()) {
$row = $rsCriteria->getRow();
$arrayDataAux2[] = array_change_key_case($row, $keyCase);
}
$arrayDataAux1[$triggerType] = $arrayDataAux2;
}
$arrayData[] = array_change_key_case($arrayDataAux1, $keyCase);
}
return $arrayData;
} catch (Exception $e) {
throw $e;
}
}
/**
* Get all users of the Task
*
* @param string $taskUid
* @param int $taskUserType
* @param bool $keyCaseToLower
*
* return array
*
* @access public
*/
public function getUsers($taskUid, $taskUserType, $keyCaseToLower = false)
{
try {
G::LoadClass("BasePeer");
$arrayData = array();
$keyCase = ($keyCaseToLower)? CASE_LOWER : CASE_UPPER;
//Criteria
$processMap = new ProcessMap();
$criteria = $processMap->getTaskUsersCriteria($taskUid, $taskUserType);
if ($criteria->getDbName() == "dbarray") {
$rsCriteria = ArrayBasePeer::doSelectRS($criteria);
} else {
$rsCriteria = GulliverBasePeer::doSelectRS($criteria);
}
$rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($rsCriteria->next()) {
$row = $rsCriteria->getRow();
$arrayData[] = array_change_key_case($row, $keyCase);
}
return $arrayData;
} catch (Exception $e) {
throw $e;
}
}
}