/** * initialize a test method */ public function setUp() { TaoPhpUnitTestRunner::initTest(); error_reporting(E_ALL); $this->userPassword = '******'; if (is_null($this->userService)) { $this->userService = wfEngine_models_classes_UserService::singleton(); } }
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; }
/** * initialize a test method */ public function setUp() { TaoPhpUnitTestRunner::initTest(); error_reporting(E_ALL); if (is_null($this->userService)) { $this->userService = wfEngine_models_classes_UserService::singleton(); } $login = '******'; $pass = '******'; $langResource = tao_models_classes_LanguageService::singleton()->getLanguageByCode(DEFAULT_LANG); $userData = array(PROPERTY_USER_LOGIN => $login, PROPERTY_USER_PASSWORD => core_kernel_users_Service::getPasswordHash()->encrypt($pass), PROPERTY_USER_DEFLG => $langResource, PROPERTY_USER_MAIL => '*****@*****.**', PROPERTY_USER_FIRSTNAME => 'Sammy', PROPERTY_USER_LASTNAME => 'Norville Rogers', PROPERTY_USER_ROLES => INSTANCE_ROLE_WORKFLOW); if (!$this->userService->loginAvailable($login)) { $this->fail('test login already taken'); } $userClass = new core_kernel_classes_Class(CLASS_WORKFLOWUSER); $this->currentUser = $userClass->createInstanceWithProperties($userData); $this->assertTrue($this->userService->loginUser($login, $pass)); $this->service = wfEngine_models_classes_NotificationService::singleton(); }
/** * initialize a test method */ public function setUp() { TaoPhpUnitTestRunner::initTest(); if (is_null($this->userService)) { $this->userService = wfEngine_models_classes_UserService::singleton(); } list($usec, $sec) = explode(" ", microtime()); $login = '******'; $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); $this->testUserClass = new core_kernel_classes_Class(CLASS_WORKFLOWUSER); $this->testUserRole = new core_kernel_classes_Resource(INSTANCE_ROLE_WORKFLOW); if (!$this->userService->loginAvailable($login)) { $this->fail('test login already taken'); } $this->currentUser = $this->testUserClass->createInstanceWithProperties($userData); if ($this->userService->loginUser($login, $pass)) { $this->currentUser = $this->userService->getCurrentUser(); $this->currentUser0 = $this->currentUser; } $this->service = wfEngine_models_classes_ProcessExecutionService::singleton(); $this->service->cache = (bool) self::SERVICE_CACHE; }
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; }
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'); } }
/** * 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'); }