diff --git a/workflow/engine/businessModel/Process.php b/workflow/engine/businessModel/Process.php new file mode 100644 index 000000000..4a15b08ee --- /dev/null +++ b/workflow/engine/businessModel/Process.php @@ -0,0 +1,509 @@ +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"] !== "") { + 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); + } +} + diff --git a/workflow/engine/businessModel/Task.php b/workflow/engine/businessModel/Task.php new file mode 100644 index 000000000..e98bc1fc9 --- /dev/null +++ b/workflow/engine/businessModel/Task.php @@ -0,0 +1,460 @@ +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 + */ + + 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; + } + } +} +