protected function logoutUser() { if (!is_null($this->currentUser)) { $loginProperty = new core_kernel_classes_Property(PROPERTY_USER_LOGIN); $this->out("logout " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"', true); $this->userService->logout(); $this->currentUser = null; } }
public static function buildCurrentUserForView() { $wfUserService = wfEngine_models_classes_UserService::singleton(); $currentUser = $wfUserService->getCurrentUser(); // username. $data['username'] = (string) $currentUser->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_USER_LOGIN)); // user roles. $data['roles'] = array(); $roles = $wfUserService->getUserRoles($currentUser); foreach ($roles as $role) { $data['roles'][] = array('uri' => $role->getUri(), 'label' => $role->getLabel()); } return $data; }
public function testGetCallUrl() { //create unique process variables for this unit test only: $variableService = wfEngine_models_classes_VariableService::singleton(); $myProcessVarCode1 = 'myProcessVarCode1' . time(); $myProcessVarCode2 = 'myProcessVarCode2' . time(); $myProcessVar1 = $variableService->getProcessVariable($myProcessVarCode1, true); $myProcessVar2 = $variableService->getProcessVariable($myProcessVarCode2, true); $parameterNames = array('param1' . time(), 'param2' . time(), 'param3' . time(), 'param4' . time()); $inputParameters = array($parameterNames[0] => $myProcessVar1, $parameterNames[1] => '^' . $myProcessVarCode2, $parameterNames[2] => 'myConstantValue', $parameterNames[3] => null); $serviceUrl = 'http://www.myWebSite.com/myServiceScript.php'; $serviceDefinition1 = $this->authoringService->createServiceDefinition('myServiceDefinition', $serviceUrl, $inputParameters); $this->assertNotNull($serviceDefinition1); $service1 = $this->authoringService->createInteractiveService($this->activity); $this->assertTrue($this->service->isInteractiveService($service1)); $this->assertTrue($this->authoringService->setCallOfServiceDefinition($service1, $serviceDefinition1)); //check call url $callUrl = $this->service->getCallUrl($service1); $this->assertEquals($callUrl, 'http://www.myWebSite.com/myServiceScript.php?'); //assign actual params: for ($i = 1; $i <= 4; $i++) { $formalParam = $this->authoringService->getFormalParameter($parameterNames[$i - 1]); $this->assertNotNull($formalParam); if (!is_null($formalParam) && $formalParam instanceof core_kernel_classes_Resource) { $defaultProcessVar = $formalParam->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_FORMALPARAMETER_DEFAULTPROCESSVARIABLE)); if (!is_null($defaultProcessVar)) { $this->assertTrue($this->authoringService->setActualParameter($service1, $formalParam, $defaultProcessVar->getUri(), PROPERTY_CALLOFSERVICES_ACTUALPARAMETERIN, PROPERTY_ACTUALPARAMETER_PROCESSVARIABLE)); } else { $this->assertTrue($this->authoringService->setActualParameter($service1, $formalParam, 'value' . $i)); } } } //a no-orthodox way to create a valid activity execution : $userService = wfEngine_models_classes_UserService::singleton(); $currentUser = new core_kernel_classes_Resource(LOCAL_NAMESPACE . '#unitTestUser'); $this->assertNotNull($currentUser); $classActivityExecution = new core_kernel_classes_Class(CLASS_ACTIVITY_EXECUTION); $activityExec1 = $classActivityExecution->createInstance('activity exec for interactive service test case'); $activityExec1->setPropertyValue(new core_kernel_classes_Property(PROPERTY_ACTIVITY_EXECUTION_CURRENT_USER), $currentUser->getUri()); $procVarValue1 = 'procVarValue1'; $procVarValue2 = 'procVarValue2'; $activityExec1->setPropertyValue(new core_kernel_classes_Property($myProcessVar1->getUri()), $procVarValue1); $activityExec1->setPropertyValue(new core_kernel_classes_Property($myProcessVar2->getUri()), $procVarValue2); //check call url again $callUrl = $this->service->getCallUrl($service1); $this->assertEquals(strlen($callUrl), strlen('http://www.myWebSite.com/myServiceScript.php?' . $parameterNames[0] . '=&' . $parameterNames[1] . '=&' . $parameterNames[2] . '=&' . $parameterNames[3] . '=&')); //and again: $callUrl = $this->service->getCallUrl($service1, $activityExec1); $this->assertEquals(strlen($callUrl), strlen('http://www.myWebSite.com/myServiceScript.php?' . $parameterNames[0] . '=procVarValue1&' . $parameterNames[1] . '=procVarValue2&' . $parameterNames[2] . '=value3&' . $parameterNames[3] . '=value4&')); $this->assertTrue(strpos($callUrl, $procVarValue1)); $this->assertTrue(strpos($callUrl, $procVarValue2)); $this->assertTrue(strpos($callUrl, $parameterNames[2] . '=value3')); $this->assertTrue(strpos($callUrl, $parameterNames[3] . '=value4')); //delete all created resources: $myProcessVar1->delete(); $myProcessVar2->delete(); $serviceDefinition1->delete(); $activityExec1->delete(); $service1->delete(); for ($i = 0; $i < 4; $i++) { $formalParam = $this->authoringService->getFormalParameter($parameterNames[$i]); $this->assertNotNull($formalParam); if (!is_null($formalParam) && $formalParam instanceof core_kernel_classes_Resource) { $this->assertTrue($formalParam->delete()); } } }
/** * Short description of method performTransition * * @access public * @author Somsack Sipasseuth, <*****@*****.**> * @param Resource processExecution * @param Resource activityExecution * @return mixed */ public function performTransition(core_kernel_classes_Resource $processExecution, core_kernel_classes_Resource $activityExecution) { $returnValue = null; $session = PHPSession::singleton(); $session->setAttribute("activityExecutionUri", $activityExecution->getUri()); //check if the transition is possible, e.g. process is not finished if ($this->isFinished($processExecution)) { return false; } //init the services $activityDefinitionService = wfEngine_models_classes_ActivityService::singleton(); $connectorService = wfEngine_models_classes_ConnectorService::singleton(); $userService = wfEngine_models_classes_UserService::singleton(); $notificationService = wfEngine_models_classes_NotificationService::singleton(); $currentUser = $userService->getCurrentUser(); //set the activity execution of the current user as finished: if ($activityExecution->exists()) { $this->activityExecutionService->finish($activityExecution); } else { throw new Exception("cannot find the activity execution of the current activity {$activityBeforeTransition->getUri()} in perform transition"); } $activityBeforeTransition = $this->activityExecutionService->getExecutionOf($activityExecution); $nextConnector = $activityDefinitionService->getUniqueNextConnector($activityBeforeTransition); if (wfEngine_models_classes_ActivityCardinalityService::singleton()->isCardinality($nextConnector)) { $nextConnector = wfEngine_models_classes_ActivityCardinalityService::singleton()->getDestination($nextConnector); } $newActivities = array(); if (!is_null($nextConnector)) { $newActivities = $this->getNewActivities($processExecution, $activityExecution, $nextConnector); } else { //final activity: $this->finish($processExecution); return array(); } if ($newActivities === false) { //means that the process must be paused before transition: transition condition not fullfilled $this->pause($processExecution); return false; } // The actual transition starts here: $newActivityExecutions = array(); if (!is_null($nextConnector)) { //trigger the forward transition: $newActivityExecutions = $this->activityExecutionService->moveForward($activityExecution, $nextConnector, $newActivities, $processExecution); //trigger the notifications $notificationService->trigger($nextConnector, $activityExecution, $processExecution); } //transition done from here: now get the following activities: //if the connector is not a parallel one, let the user continue in his current branch and prevent the pause: $uniqueNextActivityExecution = null; if (!is_null($nextConnector)) { if ($connectorService->getType($nextConnector)->getUri() != INSTANCE_TYPEOFCONNECTORS_PARALLEL) { if (count($newActivityExecutions) == 1) { //TODO: could do a double check here: if($newActivities[0] is one of the activty found in the current tokens): if ($this->activityExecutionService->checkAcl(reset($newActivityExecutions), $currentUser, $processExecution)) { $uniqueNextActivityExecution = reset($newActivityExecutions); } } } } $setPause = true; $authorizedActivityExecutions = array(); if (!count($newActivities) || $activityDefinitionService->isFinal($activityBeforeTransition)) { //there is no following activity so the process ends here: $this->finish($processExecution); return array(); } elseif (!is_null($uniqueNextActivityExecution)) { //we are certain that the next activity would be for the user so return it: $authorizedActivityExecutions[$uniqueNextActivityExecution->getUri()] = $uniqueNextActivityExecution; $setPause = false; } else { foreach ($newActivityExecutions as $activityExecutionAfterTransition) { //check if the current user is allowed to execute the activity if ($this->activityExecutionService->checkAcl($activityExecutionAfterTransition, $currentUser, $processExecution)) { $authorizedActivityExecutions[$activityExecutionAfterTransition->getUri()] = $activityExecutionAfterTransition; $setPause = false; } else { continue; } } } $returnValue = array(); //finish actions on the authorized acitivty definitions foreach ($authorizedActivityExecutions as $uri => $activityExecutionAfterTransition) { // Last but not least ... is the next activity a machine activity ? // if yes, we perform the transition. /* * @todo to be tested */ $activityAfterTransition = $this->activityExecutionService->getExecutionOf($activityExecutionAfterTransition); if ($activityDefinitionService->isHidden($activityAfterTransition)) { //required to create an activity execution here with: $currentUser = $userService->getCurrentUser(); if (is_null($currentUser)) { throw new wfEngine_models_classes_ProcessExecutionException("No current user found!"); } $activityExecutionResource = $this->initCurrentActivityExecution($processExecution, $activityExecutionAfterTransition, $currentUser, true); //force execution of the ghost actiivty //service not executed? use curl request? if (!is_null($activityExecutionResource)) { $followingActivityExecutions = $this->performTransition($processExecution, $activityExecutionResource); if (is_array($followingActivityExecutions)) { foreach ($followingActivityExecutions as $followingActivityExec) { $returnValue[$followingActivityExec->getUri()] = $followingActivityExec; } } } else { throw new wfEngine_models_classes_ProcessExecutionException('the activity execution cannot be created for the hidden activity'); } } else { $returnValue[$uri] = $activityExecutionAfterTransition; } } if ($setPause) { $this->pause($processExecution); } else { if (!$this->isFinished($processExecution)) { $this->resume($processExecution); } } return $returnValue; }
/** * Test the tokens into a parallel process */ public function testVirtualParallelJoinProcess() { error_reporting(E_ALL); $t_start = microtime(true); //init services $activityService = wfEngine_models_classes_ActivityService::singleton(); $processVariableService = wfEngine_models_classes_VariableService::singleton(); $authoringService = wfAuthoring_models_classes_ProcessService::singleton(); $activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton(); $activityExecutionService->cache = (bool) self::SERVICE_CACHE; //process definition $processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS); $processDefinition = $processDefinitionClass->createInstance('PJ processForUnitTest_' . date(DATE_ISO8601), 'created for the unit test of process execution'); $this->assertNotNull($processDefinition); /* +---------------+ | activity 0 | +-------+-------+ | +---v---+ | c 0 | split +--+-+--+ | | 3 +---------+ +---------+ unit_var_12345678 | | +-------v--------+ +-------v------+ | activity 1 | | activity 2 | +-------+--------+ +--------+-----+ | | +--------+ +--------+ +--v----v--+ | c 2 | join +----+-----+ | +-------v--------+ | activity 3 | +----------------+ */ //activities definitions $activity0 = $authoringService->createActivity($processDefinition, 'activity0'); $this->assertNotNull($activity0); $connector0 = null; $authoringService->setFirstActivity($processDefinition, $activity0); $connector0 = $authoringService->createConnector($activity0); $connectorParallele = new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_PARALLEL); $authoringService->setConnectorType($connector0, $connectorParallele); $this->assertNotNull($connector0); $parallelActivity1 = $authoringService->createActivity($processDefinition, 'activity1'); $this->assertNotNull($parallelActivity1); $roleRestrictedUser = new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER); $activityService->setAcl($parallelActivity1, $roleRestrictedUser, $this->testUserRole); //!!! it is mendatory to set the role restricted user ACL mode to make this parallel process test case work $connector1 = null; $connector1 = $authoringService->createConnector($parallelActivity1); $this->assertNotNull($connector1); $parallelActivity2 = $authoringService->createActivity($processDefinition, 'activity2'); $this->assertNotNull($parallelActivity2); $activityService->setAcl($parallelActivity2, $roleRestrictedUser, $this->testUserRole); //!!! it is mendatory to set the role restricted user ACL mode to make this parallel process test case work $connector2 = null; $connector2 = $authoringService->createConnector($parallelActivity2); $this->assertNotNull($connector2); //define parallel activities, first branch with constant cardinality value, while the second listens to a process variable: $parallelCount1 = 3; $parallelCount2 = 5; $parallelCount2_processVar_key = 'unit_var_' . time(); $parallelCount2_processVar = $processVariableService->createProcessVariable('Var for unit test', $parallelCount2_processVar_key); $prallelActivitiesArray = array($parallelActivity1->getUri() => $parallelCount1, $parallelActivity2->getUri() => $parallelCount2_processVar); $result = $authoringService->setParallelActivities($connector0, $prallelActivitiesArray); $this->assertTrue($result); //set several split variables: $splitVariable1_key = 'unit_split_var1_' . time(); $splitVariable1 = $processVariableService->createProcessVariable('Split Var1 for unit test', $splitVariable1_key); $splitVariable2_key = 'unit_split_var2_' . time(); $splitVariable2 = $processVariableService->createProcessVariable('Split Var2 for unit test', $splitVariable2_key); $splitVariablesArray = array($parallelActivity1->getUri() => array($splitVariable1), $parallelActivity2->getUri() => array($splitVariable1, $splitVariable2)); $connectorService = wfAuthoring_models_classes_ConnectorService::singleton(); $connectorService->setSplitVariables($connector0, $splitVariablesArray); $prallelActivitiesArray[$parallelActivity2->getUri()] = $parallelCount2; $joinActivity = $authoringService->createActivity($processDefinition, 'activity3'); //join parallel Activity 1 and 2 to "joinActivity" $connector1 = wfAuthoring_models_classes_ConnectorService::singleton()->createJoin(array($parallelActivity1, $parallelActivity2), $joinActivity); /* $authoringService->createJoinActivity($connector1, $joinActivity, '', $parallelActivity1); $authoringService->createJoinActivity($connector2, $joinActivity, '', $parallelActivity2); */ //run the process $processExecName = 'Test Parallel Process Execution'; $processExecComment = 'created for processExecustionService test case by ' . __METHOD__; $processInstance = $this->service->createProcessExecution($processDefinition, $processExecName, $processExecComment); $this->assertTrue($this->service->checkStatus($processInstance, 'started')); $this->out(__METHOD__, true); $this->out("<strong>Forward transitions:</strong>", true); $previousActivityExecution = null; $numberActivities = 2 + $parallelCount1 + $parallelCount2; $createdUsers = array(); $loginProperty = new core_kernel_classes_Property(PROPERTY_USER_LOGIN); for ($i = 1; $i <= $numberActivities; $i++) { $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $countActivities = count($activitieExecs); $activity = null; $activityExecution = null; if ($countActivities > 1) { //select one of the available activities in the parallel branch: foreach ($activitieExecs as $activityExecUri => $activityExec) { if (!$activityExecutionService->isFinished($activityExec)) { $activityDefinition = $activityExecutionService->getExecutionOf($activityExec); $activityUri = $activityDefinition->getUri(); if (isset($prallelActivitiesArray[$activityUri])) { if ($prallelActivitiesArray[$activityUri] > 0) { $prallelActivitiesArray[$activityUri]--; $activityExecution = $activityExec; $activity = $activityDefinition; break; } } } } } else { if ($countActivities == 1) { $activityExecution = reset($activitieExecs); $activity = $activityExecutionService->getExecutionOf($activityExecution); } else { $this->fail('no current activity definition found for the iteration ' . $i); } } $this->out("<strong> Iteration {$i} :</strong>", true); $this->out("<strong>" . (is_null($activity) ? 'null' : $activity->getLabel()) . "</strong> (among {$countActivities})"); //issue : no activity found for the last iteration... //init execution $activityExecution = $this->service->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser); $this->assertNotNull($activityExecution); if ($i == 1) { //set value of the parallel thread: $processVariableService->push($parallelCount2_processVar_key, $parallelCount2); //set some values to the split variables: $values1 = array(); for ($j = 1; $j <= $parallelCount1; $j++) { $values1[] = 'A' . $j; } $values2 = array(); for ($j = 1; $j <= $parallelCount2; $j++) { $values2[] = 'B' . $j; } $processVariableService->push($splitVariable1_key, serialize($values1)); $processVariableService->push($splitVariable2_key, serialize($values2)); } else { //check dispatched value: // $value1 = $processVariableService->get($splitVariable1_key); // $value2 = $processVariableService->get($splitVariable2_key); // var_dump($value1, $value2); } $activityExecStatus = $activityExecutionService->getStatus($activityExecution); $this->assertNotNull($activityExecStatus); $this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_STARTED); //transition to next activity $this->out("current user: "******"' . $this->currentUser->getUri() . '"'); $this->out("performing transition ..."); //transition to next activity $performed = $this->service->performTransition($processInstance, $activityExecution); if (!$performed) { $this->out('transition failed.'); } $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $this->service->getStatus($processInstance)->getLabel()); //try undoing the transition: switch ($i) { case 1: $this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution)); $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($activitieExecs), 1); $activityBis = $activityExecutionService->getExecutionOf(reset($activitieExecs)); $this->assertTrue($activity->getUri() == $activityBis->getUri()); $transitionResult = $this->service->performTransition($processInstance, $activityExecution); break; case 1 + $parallelCount1: $this->assertFalse($this->service->undoForwardTransition($processInstance, $activityExecution)); $history = $this->service->getExecutionHistory($processInstance); $this->assertEquals(count($history), 2 * ($parallelCount1 + $parallelCount2) + 1); //activity 1, 2(closed), 2, 3 and 4 $this->assertFalse($this->service->undoForwardTransition($processInstance, new core_kernel_classes_Resource(reset($history)))); $this->assertNotNull($previousActivityExecution); $this->assertFalse($this->service->undoForwardTransition($processInstance, $previousActivityExecution)); break; case 1 + $parallelCount1 + $parallelCount2: $this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution)); $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($activitieExecs), $parallelCount1 + $parallelCount2); $transitionResult = $this->service->performTransition($processInstance, $activityExecution); break; } $previousActivityExecution = $activityExecution; if ($this->service->isPaused($processInstance)) { //Login another user to execute parallel branch $this->userService->logout(); $this->out("logout " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"', true); list($usec, $sec) = explode(" ", microtime()); $login = '******' . $i . '-' . $usec; $pass = '******'; $userData = array(PROPERTY_USER_LOGIN => $login, PROPERTY_USER_PASSWORD => core_kernel_users_Service::getPasswordHash()->encrypt($pass), PROPERTY_USER_DEFLG => 'http://www.tao.lu/Ontologies/TAO.rdf#Lang' . DEFAULT_LANG, PROPERTY_USER_UILG => 'http://www.tao.lu/Ontologies/TAO.rdf#Lang' . DEFAULT_LANG, PROPERTY_USER_ROLES => INSTANCE_ROLE_WORKFLOW, RDFS_LABEL => $login); if (!$this->userService->loginAvailable($login)) { $this->fail('test login already taken'); } $otherUser = $this->testUserClass->createInstanceWithProperties($userData); $createdUsers[$otherUser->getUri()] = $otherUser; if ($this->userService->loginUser($login, $pass)) { $this->currentUser = $this->userService->getCurrentUser(); $this->out("new user logged in: " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"'); } else { $this->fail("unable to login user {$login}"); } } } $this->assertTrue($this->service->isFinished($processInstance)); $this->assertTrue($this->service->resume($processInstance)); $this->out("<strong>Backward transitions:</strong>", true); // var_dump($this->service->getAllActivityExecutions($processInstance)); $j = 0; $iterationNumber = 2; while ($j < $iterationNumber) { $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $activityExecution = null; $activity = null; switch ($j) { case 0: $this->assertEquals(count($activitieExecs), 1); //check $activityExecution = reset($activitieExecs); $activity = $activityExecutionService->getExecutionOf($activityExecution); break; case 1: $this->assertEquals(count($activitieExecs), $parallelCount1 + $parallelCount2); //check $activity = $parallelActivity2; foreach ($this->service->getCurrentActivityExecutions($processInstance, $activity) as $activityExec) { if ($activityExecutionService->getActivityExecutionUser($activityExec)->getUri() == $this->currentUser->getUri()) { $activityExecution = $activityExec; } } if (is_null($activityExecution)) { $activity = $parallelActivity1; foreach ($this->service->getCurrentActivityExecutions($processInstance, $activity) as $activityExec) { if ($activityExecutionService->getActivityExecutionUser($activityExec)->getUri() == $this->currentUser->getUri()) { $activityExecution = $activityExec; } } } $this->assertNotNull($activityExecution); break; } $this->out("<strong>" . $activity->getLabel() . "</strong>", true); //init execution $activityExecution = $this->service->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser); $this->assertNotNull($activityExecution); $activityExecStatus = $activityExecutionService->getStatus($activityExecution); $this->assertNotNull($activityExecStatus); $this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED); $this->out("current user: "******"' . $this->currentUser->getUri() . '"'); $this->out("performing transition ..."); //transition to next activity $transitionResult = $this->service->performBackwardTransition($processInstance, $activityExecution); if ($j == 0) { $this->assertTrue(count($transitionResult) > 0); } else { if ($j == $iterationNumber - 1) { //var_dump($transitionResult); $this->assertFalse($transitionResult); } } $processStatus = $this->service->getStatus($processInstance); $this->assertNotNull($processStatus); $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $processStatus->getLabel()); $this->assertEquals($processStatus->getUri(), INSTANCE_PROCESSSTATUS_PAUSED); $j++; } $this->out("<strong>Forward transitions again:</strong>", true); $currentActivityExecutions = $this->service->getCurrentActivityExecutions($processInstance); $currentActivityExecutionsCount = count($currentActivityExecutions); $this->assertEquals($currentActivityExecutionsCount, $parallelCount1 + $parallelCount2); for ($i = 0; $i < $currentActivityExecutionsCount; $i++) { $currentActivityExecution = array_pop($currentActivityExecutions); $user = $activityExecutionService->getActivityExecutionUser($currentActivityExecution); $activityDefinition = $activityExecutionService->getExecutionOf($currentActivityExecution); $this->assertNotNull($user); $this->assertNotNull($activityDefinition); if (!is_null($user) && !is_null($activityDefinition)) { $this->userService->logout(); $this->out("logout " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"', true); $login = (string) $user->getUniquePropertyValue($loginProperty); $pass = '******'; if ($this->userService->loginUser($login, $pass)) { $this->currentUser = $this->userService->getCurrentUser(); $this->out("new user logged in: " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"'); } else { $this->fail("unable to login user {$login}<br>"); } $iterationNo = $i + 1; $this->out("<strong>Iteration {$iterationNo}: " . $activityDefinition->getLabel() . "</strong>", true); //execute activity: $activityExecution = $this->service->initCurrentActivityExecution($processInstance, $currentActivityExecution, $this->currentUser); $this->assertNotNull($activityExecution); $activityExecStatus = $activityExecutionService->getStatus($activityExecution); $this->assertNotNull($activityExecStatus); $this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED); //transition to next activity $this->out("current user: "******"' . $this->currentUser->getUri() . '"'); $this->out("performing transition ..."); //transition to next activity $this->service->performTransition($processInstance, $activityExecution); $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $this->service->getStatus($processInstance)->getLabel()); //try undoing the transition: if ($i < $currentActivityExecutionsCount - 1) { $this->assertFalse($this->service->undoForwardTransition($processInstance, $activityExecution)); } } } //try undoing the transition: $this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution)); $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($activitieExecs), $parallelCount1 + $parallelCount2); $transitionResult = $this->service->performTransition($processInstance, $activityExecution); $this->assertEquals(count($transitionResult), 1); $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($activitieExecs), 1); $activityExecution = reset($activitieExecs); $activity = $activityExecutionService->getExecutionOf($activityExecution); $this->assertEquals($activity->getUri(), $joinActivity->getUri()); $this->out("<strong>Executing last activity: " . $activity->getLabel() . "</strong>", true); //init execution $activityExecution = $this->service->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser); $this->assertNotNull($activityExecution); $activityExecStatus = $activityExecutionService->getStatus($activityExecution); $this->assertNotNull($activityExecStatus); $this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_STARTED); //transition to next activity $this->out("current user: "******"' . $this->currentUser->getUri() . '"'); $this->out("performing transition ..."); //transition to next activity $this->service->performTransition($processInstance, $activityExecution); $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $this->service->getStatus($processInstance)->getLabel()); $this->assertTrue($this->service->isFinished($processInstance)); $t_end = microtime(true); $duration = $t_end - $t_start; $this->out('Elapsed time: ' . $duration . 's', true); $this->out('deleting created resources:', true); //delete process exec: $this->assertTrue($this->service->deleteProcessExecution($processInstance)); //delete processdef: $this->assertTrue($authoringService->deleteProcess($processDefinition)); $parallelCount2_processVar->delete(); //delete created users: foreach ($createdUsers as $createdUser) { $this->out('deleting ' . $createdUser->getLabel() . ' "' . $createdUser->getUri() . '"'); $this->assertTrue($this->userService->removeUser($createdUser)); } if (!is_null($this->currentUser)) { $this->userService->logout(); $this->userService->removeUser($this->currentUser); } }
public function index() { if (is_null($this->processExecution)) { common_Logger::w('ProcessBrowser invoked without processExecution'); $this->redirectToMain(); return; } if ($this->autoRedirecting) { $this->autoredirectToIndex(); return; } /* * @todo: clean usage * known use of Session::setAttribute("processUri") in: * - taoDelivery_actions_ItemDelivery::runner() * - tao_actions_Api::createAuthEnvironment() */ $this->setSessionAttribute("processUri", $this->processExecution->getUri()); //user data for browser view $userViewData = wfEngine_helpers_UsersHelper::buildCurrentUserForView(); $this->setData('userViewData', $userViewData); $browserViewData = array(); // general data for browser view. //init services: $userService = wfEngine_models_classes_UserService::singleton(); $activityService = wfEngine_models_classes_ActivityService::singleton(); $interactiveServiceService = wfEngine_models_classes_InteractiveServiceService::singleton(); //get current user: $currentUser = $userService->getCurrentUser(); if (is_null($currentUser)) { throw new wfEngine_models_classes_ProcessExecutionException("No current user found!"); } //get activity execution from currently available process definitions: $currentlyAvailableActivityExecutions = $this->processExecutionService->getAvailableCurrentActivityExecutions($this->processExecution, $currentUser, true); $activityExecution = null; if (count($currentlyAvailableActivityExecutions) == 0) { common_Logger::w('No available current activity exec found: no permission or issue in process execution'); $this->pause(); return; } else { if (!is_null($this->activityExecution) && $this->activityExecution instanceof core_kernel_classes_Resource) { foreach ($currentlyAvailableActivityExecutions as $availableActivityExec) { if ($availableActivityExec->getUri() == $this->activityExecution->getUri()) { $activityExecution = $this->processExecutionService->initCurrentActivityExecution($this->processExecution, $this->activityExecution, $currentUser); break; } } if (is_null($activityExecution)) { //invalid choice of activity execution: $this->activityExecution = null; // $invalidActivity = new core_kernel_classes_Resource($activityUri); // throw new wfEngine_models_classes_ProcessExecutionException("invalid choice of activity definition in process browser {$invalidActivity->getLabel()} ({$invalidActivity->getUri()}). \n<br/> The link may be outdated."); $this->autoredirectToIndex(); return; } } else { if (count($currentlyAvailableActivityExecutions) == 1) { $activityExecution = $this->processExecutionService->initCurrentActivityExecution($this->processExecution, reset($currentlyAvailableActivityExecutions), $currentUser); if (is_null($activityExecution)) { throw new wfEngine_models_classes_ProcessExecutionException('cannot initiate the activity execution of the unique next activity definition'); } } else { //count > 1: //parallel branch, ask the user to select activity to execute: common_Logger::i('Ask the user to select activity'); $this->pause(); return; } } } if (!is_null($activityExecution)) { $this->activityExecution = $activityExecution; $browserViewData[''] = $this->processExecution->getUri(); $browserViewData['activityExecutionUri'] = $activityExecution->getUri(); $this->activityExecutionService->createNonce($this->activityExecution); $browserViewData['activityExecutionNonce'] = $this->activityExecutionService->getNonce($activityExecution); //get interactive services (call of services): $activityDefinition = $this->activityExecutionService->getExecutionOf($activityExecution); $interactiveServices = $activityService->getInteractiveServices($activityDefinition); $services = array(); foreach ($interactiveServices as $interactiveService) { $serviceCallModel = tao_models_classes_service_ServiceCall::fromResource($interactiveService); $vars = $serviceCallModel->getRequiredVariables(); $parameters = array(); foreach ($vars as $variable) { $key = (string) $variable->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_PROCESSVARIABLES_CODE)); $value = $activityExecution->getOnePropertyValue(new core_kernel_classes_Property($variable)); if ($value instanceof core_kernel_classes_Resource) { $parameters[$key] = $value->getUri(); } elseif ($value instanceof core_kernel_classes_Literal) { $parameters[$key] = (string) $value; } } $serviceCallId = $activityExecution->getUri() . (count($interactiveServices) == 1 ? '' : $interactiveService->getUri()); $jsServiceApi = tao_helpers_ServiceJavascripts::getServiceApi($serviceCallModel, $serviceCallId, $parameters); $services[] = array('style' => $interactiveServiceService->getStyle($interactiveService), 'api' => $jsServiceApi); } $this->setData('services', $services); //set activity control: $controls = $activityService->getControls($activityDefinition); $browserViewData['controls'] = array('backward' => isset($controls[INSTANCE_CONTROL_BACKWARD]) ? (bool) $controls[INSTANCE_CONTROL_BACKWARD] : false, 'forward' => isset($controls[INSTANCE_CONTROL_FORWARD]) ? (bool) $controls[INSTANCE_CONTROL_FORWARD] : false); // If paused, resume it: if ($this->processExecutionService->isFinished($this->processExecution)) { $this->processExecutionService->resume($this->processExecution); } //get process definition: $processDefinition = $this->processExecutionService->getExecutionOf($this->processExecution); // Browser view main data. $browserViewData['processLabel'] = $processDefinition->getLabel(); $browserViewData['processExecutionLabel'] = $this->processExecution->getLabel(); $browserViewData['activityLabel'] = $activityDefinition->getLabel(); $browserViewData['processUri'] = $this->processExecution->getUri(); $browserViewData['active_Resource'] = "'" . $activityDefinition->getUri() . "'"; $browserViewData['isInteractiveService'] = true; $this->setData('browserViewData', $browserViewData); $this->setData('activity', $activityDefinition); /* <DEBUG> :populate the debug widget */ if (DEBUG_MODE) { $this->setData('debugWidget', DEBUG_MODE); $servicesResources = array(); foreach ($services as $service) { $servicesResource = $service; $servicesResource['input'] = $interactiveServiceService->getInputValues($interactiveService, $activityExecution); $servicesResource['output'] = $interactiveServiceService->getOutputValues($interactiveService, $activityExecution); $servicesResources[] = $servicesResource; } $variableService = wfEngine_models_classes_VariableService::singleton(); $this->setData('debugData', array('Activity' => $activityDefinition, 'ActivityExecution' => $activityExecution, 'CurrentActivities' => $currentlyAvailableActivityExecutions, 'Services' => $servicesResources, 'VariableStack' => $variableService->getAll())); } /* </DEBUG> */ $this->setData('activityExecutionUri', $browserViewData['activityExecutionUri']); $this->setData('processUri', $browserViewData['processUri']); $this->setData('activityExecutionNonce', $browserViewData['activityExecutionNonce']); $this->setData('client_config_url', $this->getClientConfigUrl()); $this->setView('process_browser.tpl'); } }
/** * Test the notifications in a sequencial process */ public function testNotificationsInProcess() { try { $processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton(); $authoringService = wfAuthoring_models_classes_ProcessService::singleton(); $activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton(); $roleService = wfEngine_models_classes_RoleService::singleton(); //create a new process def $processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS); $processDefinition = $processDefinitionClass->createInstance('ProcessForUnitTest', 'Unit test'); $this->assertIsA($processDefinition, 'core_kernel_classes_Resource'); $aclModeRole = new core_kernel_classes_Resource(INSTANCE_ACL_ROLE); $aclModeUser = new core_kernel_classes_Resource(INSTANCE_ACL_USER); $wfRole = new core_kernel_classes_Resource(INSTANCE_ROLE_WORKFLOW); $role1 = $roleService->addRole('Role 1', $wfRole); $role2 = $roleService->addRole('Role 2', $wfRole); $roleService->setRoleToUsers($role2, array($this->currentUser)); //define activities and connectors $activity1 = $authoringService->createActivity($processDefinition, 'activity1'); $this->assertNotNull($activity1); $authoringService->setFirstActivity($processDefinition, $activity1); //activity is allowed to the created role $activityExecutionService->setAcl($activity1, $aclModeRole, $role2); $connector1 = null; $connector1 = $authoringService->createConnector($activity1); $authoringService->setConnectorType($connector1, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE)); $this->assertNotNull($connector1); $this->service->bindProperties($connector1, array(PROPERTY_CONNECTORS_NOTIFY => INSTANCE_NOTIFY_USER, PROPERTY_CONNECTORS_USER_NOTIFIED => $this->currentUser->getUri(), PROPERTY_CONNECTORS_NOTIFICATION_MESSAGE => 'Connector 1 notification to user ' . $this->currentUser->getLabel())); $activity2 = $authoringService->createSequenceActivity($connector1, null, 'activity2'); $this->assertNotNull($activity2); //2nd activity is allowed to create role $activityExecutionService->setAcl($activity2, $aclModeRole, $role2); $connector2 = null; $connector2 = $authoringService->createConnector($activity2); $authoringService->setConnectorType($connector2, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE)); $this->assertNotNull($connector2); $this->service->bindProperties($connector2, array(PROPERTY_CONNECTORS_NOTIFY => INSTANCE_NOTIFY_PREVIOUS, PROPERTY_CONNECTORS_NOTIFICATION_MESSAGE => 'Connector 2 notification to previous activity user ' . $this->currentUser->getLabel())); $activity3 = $authoringService->createSequenceActivity($connector2, null, 'activity3'); $this->assertNotNull($activity3); $connector3 = null; $connector3 = $authoringService->createConnector($activity3); $authoringService->setConnectorType($connector3, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE)); $this->assertNotNull($connector3); $this->service->bindProperties($connector3, array(PROPERTY_CONNECTORS_NOTIFY => INSTANCE_NOTIFY_NEXT, PROPERTY_CONNECTORS_NOTIFICATION_MESSAGE => 'Connector 3 notification to next activity user ' . $this->currentUser->getLabel())); $activity4 = $authoringService->createSequenceActivity($connector3, null, 'activity4'); $this->assertNotNull($activity4); //allowed to the currentUser only $activityExecutionService->setAcl($activity4, $aclModeUser, $this->currentUser); $connector4 = null; $connector4 = $authoringService->createConnector($activity4); $authoringService->setConnectorType($connector4, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE)); $this->assertNotNull($connector4); $this->service->bindProperties($connector4, array(PROPERTY_CONNECTORS_NOTIFY => INSTANCE_NOTIFY_ROLE, PROPERTY_CONNECTORS_ROLE_NOTIFIED => $role2->getUri(), PROPERTY_CONNECTORS_NOTIFICATION_MESSAGE => 'Connector 4 notification to role user ' . $role2->getLabel())); $activity5 = $authoringService->createSequenceActivity($connector4, null, 'activity5'); $this->assertNotNull($activity5); //run the process $processExecName = 'Test Process Execution'; $processExecComment = 'created for Notification service test case by ' . __METHOD__; $proc = $processExecutionService->createProcessExecution($processDefinition, $processExecName, $processExecComment); $i = 1; while ($i <= 5) { $activityExecs = $processExecutionService->getAvailableCurrentActivityExecutions($proc, $this->currentUser); $this->assertEquals(count($activityExecs), 1); $activityExec = reset($activityExecs); $activity = $activityExecutionService->getExecutionOf($activityExec); $this->out("<strong>" . $activity->getLabel() . "</strong>", true); $this->assertTrue($activity->getLabel() == 'activity' . $i); //init execution $activityExecution = $processExecutionService->initCurrentActivityExecution($proc, $activityExec, $this->currentUser); $this->assertIsA($activityExecution, "core_kernel_classes_Resource"); //transition to nextactivity $transitionResult = $processExecutionService->performTransition($proc, $activityExecution); $this->assertFalse($processExecutionService->isPaused($proc)); $i++; } $this->assertTrue($processExecutionService->isFinished($proc)); //check the created notifications $notifications = array(); $notificationProcessExecProp = new core_kernel_classes_Property(PROPERTY_NOTIFICATION_PROCESS_EXECUTION); $notificationToProp = new core_kernel_classes_Property(PROPERTY_NOTIFICATION_TO); $notificationsToSend = $this->service->getNotificationsToSend(); $this->assertTrue(count($notificationsToSend) > 0); foreach ($this->service->getNotificationsToSend() as $notification) { $notificationProcess = $notification->getOnePropertyValue($notificationProcessExecProp); if (!is_null($notificationProcess)) { if ($notificationProcess->getUri() == $proc->getUri()) { $notifiedUser = $notification->getOnePropertyValue($notificationToProp); $this->assertNotNull($notifiedUser); $this->assertEquals($notifiedUser->getUri(), $this->currentUser->getUri()); $notifications[] = $notification; } } } $notificationCount = count($notifications); $this->assertEquals($notificationCount, 4); // $this->out("$notificationCount notifications to be sent"); // $this->assertTrue($this->service->sendNotifications(new tao_helpers_transfert_MailAdapter())); // $this->out("All notifications sent"); //delete notifications: foreach ($notifications as $notification) { $this->assertTrue($notification->delete()); } $this->assertTrue($role2->delete()); //delete process exec: $this->assertTrue($processExecutionService->deleteProcessExecution($proc)); //delete processdef: $this->assertTrue($authoringService->deleteProcess($processDefinition)); if (!is_null($this->currentUser)) { $this->userService->logout(); $this->assertTrue($this->userService->removeUser($this->currentUser)); } } catch (common_Exception $ce) { $this->fail($ce); } }
/** * Short description of method getValue * * @access public * @author Joel Bout, <*****@*****.**> * @param string rowId * @param string columnId * @param string data * @return mixed */ public function getValue($rowId, $columnId, $data = null) { $returnValue = null; if (isset($this->data[$rowId])) { //return values: if (isset($this->data[$rowId][$columnId])) { $returnValue = $this->data[$rowId][$columnId]; } } else { // 'PROPERTY_ACTIVITY_EXECUTION_CTX_RECOVERY' => NS_WFENGINE . '#PropertyActivityExecutionsContextRecovery', // 'PROPERTY_ACTIVITY_EXECUTION_VARIABLES' => NS_WFENGINE .'#PropertyActivityExecutionsHasVariables', // 'PROPERTY_ACTIVITY_EXECUTION_PREVIOUS' => NS_WFENGINE .'#PropertyActivityExecutionsPreviousActivityExecutions', // 'PROPERTY_ACTIVITY_EXECUTION_FOLLOWING' => NS_WFENGINE .'#PropertyActivityExecutionsFollowingActivityExecutions', // 'PROPERTY_ACTIVITY_EXECUTION_NONCE' => NS_WFENGINE . '#PropertyActivityExecutionsNonce', if (common_Utils::isUri($rowId)) { $excludedProperties = $this->excludedProperties; $activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton(); $activityExecution = new core_kernel_classes_Resource($rowId); $status = $activityExecutionService->getStatus($activityExecution); $this->data[$rowId] = array(); if (!in_array(PROPERTY_ACTIVITY_EXECUTION_ACTIVITY, $excludedProperties)) { $activityExecutionOf = $activityExecutionService->getExecutionOf($activityExecution); $this->data[$rowId][PROPERTY_ACTIVITY_EXECUTION_ACTIVITY] = $activityExecutionOf->getLabel(); } if (!in_array(PROPERTY_ACTIVITY_EXECUTION_STATUS, $excludedProperties)) { $this->data[$rowId][PROPERTY_ACTIVITY_EXECUTION_STATUS] = is_null($status) ? null : $status->getLabel(); } $timeProperties = array(PROPERTY_ACTIVITY_EXECUTION_TIME_CREATED, PROPERTY_ACTIVITY_EXECUTION_TIME_STARTED, PROPERTY_ACTIVITY_EXECUTION_TIME_LASTACCESS); foreach ($timeProperties as $timeProperty) { if (!in_array($timeProperty, $excludedProperties)) { $time = (string) $activityExecution->getOnePropertyValue(new core_kernel_classes_Property($timeProperty)); $this->data[$rowId][$timeProperty] = !empty($time) ? date('d-m-Y G:i:s', $time) : 'n/a'; } } if (!in_array(PROPERTY_ACTIVITY_EXECUTION_CURRENT_USER, $excludedProperties)) { $user = $activityExecutionService->getActivityExecutionUser($activityExecution); $this->data[$rowId][PROPERTY_ACTIVITY_EXECUTION_CURRENT_USER] = is_null($user) ? 'n/a' : $user->getLabel(); } if (!in_array(PROPERTY_ACTIVITY_EXECUTION_ACL_MODE, $excludedProperties)) { $aclMode = $activityExecutionService->getAclMode($activityExecution); $this->data[$rowId][PROPERTY_ACTIVITY_EXECUTION_ACL_MODE] = is_null($aclMode) ? 'n/a' : $aclMode->getLabel(); } if (!in_array(PROPERTY_ACTIVITY_EXECUTION_RESTRICTED_USER, $excludedProperties)) { $restricedRole = $activityExecutionService->getRestrictedRole($activityExecution); $restrictedTo = !is_null($restricedRole) ? $restricedRole : $activityExecutionService->getRestrictedUser($activityExecution); $this->data[$rowId][PROPERTY_ACTIVITY_EXECUTION_RESTRICTED_USER] = is_null($restrictedTo) ? 'n/a' : $restrictedTo->getLabel(); } if (!in_array(PROPERTY_ACTIVITY_EXECUTION_PROCESSEXECUTION, $excludedProperties)) { $processExecution = $activityExecutionService->getRelatedProcessExecution($activityExecution); $this->data[$rowId][PROPERTY_ACTIVITY_EXECUTION_PROCESSEXECUTION] = is_null($processExecution) ? 'n/a' : $processExecution->getUri(); } if (!in_array('runnable', $excludedProperties)) { $runnable = false; $crtUser = wfEngine_models_classes_UserService::singleton()->getCurrentUser(); if (!is_null($crtUser)) { /** * @todo the null status should not exist * @see Sam when a change will occur */ $runnable = is_null($status) || $status->getUri() != INSTANCE_PROCESSSTATUS_FINISHED && $status->getUri() != INSTANCE_PROCESSSTATUS_CLOSED && $status->getUri() != INSTANCE_PROCESSSTATUS_STOPPED && $activityExecutionService->checkAcl($activityExecution, $crtUser); } $this->data[$rowId]['runnable'] = $runnable; } if (isset($this->data[$rowId][$columnId])) { $returnValue = $this->data[$rowId][$columnId]; } } } return $returnValue; }
/** * * Main page of wfEngine containning 2 sections : * - Processes Execution in progress or just started * - Processes Definition user may instanciate * * @return void */ public function index() { //init required services $activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton(); $processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton(); $processDefinitionService = wfEngine_models_classes_ProcessDefinitionService::singleton(); $userService = wfEngine_models_classes_UserService::singleton(); //get current user: $currentUser = $userService->getCurrentUser(); //init variable that save data to be used in the view $processViewData = array(); $userViewData = wfEngine_helpers_UsersHelper::buildCurrentUserForView(); $this->setData('userViewData', $userViewData); //list of available process executions: $processInstancesClass = new core_kernel_classes_Class(CLASS_PROCESSINSTANCES); $processExecutions = $processInstancesClass->getInstances(); foreach ($processExecutions as $processExecution) { if (!is_null($processExecution) && $processExecution instanceof core_kernel_classes_Resource) { try { $processDefinition = $processExecutionService->getExecutionOf($processExecution); } catch (wfEngine_models_classes_ProcessExecutionException $e) { $processDefinition = null; $processExecutionService->deleteProcessExecution($processExecution); continue; } $processStatus = $processExecutionService->getStatus($processExecution); if (is_null($processStatus) || !$processStatus instanceof core_kernel_classes_Resource) { continue; } $currentActivities = array(); // Bypass ACL Check if possible... if ($processStatus->getUri() == INSTANCE_PROCESSSTATUS_FINISHED) { $processViewData[] = array('type' => $processDefinition->getLabel(), 'label' => $processExecution->getLabel(), 'uri' => $processExecution->getUri(), 'activities' => array(array('label' => '', 'uri' => '', 'may_participate' => false, 'finished' => true, 'allowed' => true)), 'status' => $processStatus); continue; } else { $currentActivityExecutions = $processExecutionService->getCurrentActivityExecutions($processExecution); foreach ($currentActivityExecutions as $uri => $currentActivityExecution) { $isAllowed = $activityExecutionService->checkAcl($currentActivityExecution, $currentUser, $processExecution); $activityExecFinishedByUser = false; $assignedUser = $activityExecutionService->getActivityExecutionUser($currentActivityExecution); if (!is_null($assignedUser) && $assignedUser->getUri() == $currentUser->getUri()) { $activityExecFinishedByUser = $activityExecutionService->isFinished($currentActivityExecution); } $currentActivity = $activityExecutionService->getExecutionOf($currentActivityExecution); $currentActivities[] = array('label' => $currentActivity->getLabel(), 'uri' => $uri, 'may_participate' => $processStatus->getUri() != INSTANCE_PROCESSSTATUS_FINISHED && $isAllowed, 'finished' => $processStatus->getUri() == INSTANCE_PROCESSSTATUS_FINISHED, 'allowed' => $isAllowed, 'activityEnded' => $activityExecFinishedByUser); } $processViewData[] = array('type' => $processDefinition->getLabel(), 'label' => $processExecution->getLabel(), 'uri' => $processExecution->getUri(), 'activities' => $currentActivities, 'status' => $processStatus); } } } //list of available process definitions: $processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS); $availableProcessDefinitions = $processDefinitionClass->getInstances(); //filter process that can be initialized by the current user (2nd check...) $authorizedProcessDefinitions = array(); foreach ($availableProcessDefinitions as $processDefinition) { if ($processDefinitionService->checkAcl($processDefinition, $currentUser)) { $authorizedProcessDefinitions[] = $processDefinition; } } $this->setData('availableProcessDefinition', $authorizedProcessDefinitions); $this->setData('processViewData', $processViewData); $this->setView('main.tpl'); }