public function __construct()
{
parent::__construct();
$this->values = array();
$this->variableService = wfEngine_models_classes_VariableService::singleton();
if (!$this->activityExecution->hasType(new core_kernel_classes_Class(CLASS_ACTIVITY_EXECUTION))) {
$this->activityExecution = null;
$this->setErrorMessage(__('The resource is not an activity execution'));
}
$code = urldecode($this->getRequestParameter('code'));
if (!empty($code)) {
if (is_null($this->variableService->getProcessVariable($code))) {
$this->setErrorMessage(__('The variable with the code ' . $code . ' does not exists'));
} else {
$this->code = $code;
}
} else {
$this->setErrorMessage(__('No variable code given'));
}
// don't use getRequestParameter since it modifies the params
if (isset($_REQUEST['value'])) {
$values = $_REQUEST['value'];
if (is_array($values)) {
foreach ($values as $value) {
$this->values[] = urldecode($value);
}
} else {
$this->values[] = urldecode($values);
}
}
}
public function __construct()
{
//init services
$this->activityService = wfEngine_models_classes_ActivityService::singleton();
$this->processVariableService = wfEngine_models_classes_VariableService::singleton();
$this->authoringService = wfAuthoring_models_classes_ProcessService::singleton();
$this->activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
$this->connectorService = wfEngine_models_classes_ConnectorService::singleton();
$this->processVariablesClass = new core_kernel_classes_Class(CLASS_PROCESSVARIABLES);
$this->propertyIsSample = new core_kernel_classes_Property(PROPERTY_IS_SAMPLE);
}
/**
* tests initialization
*/
public function setUp()
{
TaoPhpUnitTestRunner::initTest();
$processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS);
$processDefinition = $processDefinitionClass->createInstance('processForUnitTest', 'created for the unit test of process authoring service');
if ($processDefinition instanceof core_kernel_classes_Resource) {
$this->proc = $processDefinition;
} else {
$this->fail('fail to create a process definition resource');
}
$this->apiModel = core_kernel_impl_ApiModelOO::singleton();
$this->variableService = wfEngine_models_classes_VariableService::singleton();
$this->authoringService = wfAuthoring_models_classes_ProcessService::singleton();
}
/**
* Short description of method evaluate
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param values
* @return boolean
*/
public function evaluate($values)
{
$returnValue = (bool) false;
$returnValue = true;
if (isset($this->options['uri'])) {
$variableService = wfEngine_models_classes_VariableService::singleton();
$processVar = $variableService->getProcessVariable($values);
if (!is_null($processVar)) {
if ($this->options['uri'] != $processVar->getUri()) {
$returnValue = false;
}
}
}
return (bool) $returnValue;
}
/**
* tests initialization
*/
public function setUp()
{
TaoPhpUnitTestRunner::initTest();
$this->authoringService = wfAuthoring_models_classes_ProcessService::singleton();
$this->variableService = wfEngine_models_classes_VariableService::singleton();
$processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS);
$this->processDefinition = $processDefinitionClass->createInstance('ProcessForUnitTest', 'Unit test');
//define activities and connectors
$activity = $this->authoringService->createActivity($this->processDefinition, 'activity for interactive service unit test');
if ($activity instanceof core_kernel_classes_Resource) {
$this->activity = $activity;
} else {
$this->fail('fail to create a process definition resource');
}
$this->service = wfEngine_models_classes_ConnectorService::singleton();
}
public function testGetProcessVars()
{
$processVars = $this->service->getProcessVars($this->processDefinition);
$this->assertEquals(count($processVars), 1);
$variableService = wfEngine_models_classes_VariableService::singleton();
$myProcessVarName1 = 'myProcDefVarName1';
$myProcessVar1 = $variableService->getProcessVariable($myProcessVarName1, true);
$this->service->setProcessVariable($this->processDefinition, $myProcessVarName1);
//this works too: $this->service->setProcessVariable($this->processDefinition, $myProcessVar1);
$processVars = $this->service->getProcessVars($this->processDefinition);
$this->assertEquals(count($processVars), 2);
$this->assertTrue(isset($processVars[$myProcessVar1->getUri()]));
$secondProcessVar = $processVars[$myProcessVar1->getUri()];
$this->assertEquals($secondProcessVar['name'], $myProcessVarName1);
$myProcessVar1->delete();
}
/**
* 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');
}
}
/**
* Short description of method getRestrictedUser
*
* @access public
* @author Somsack Sipasseuth, <*****@*****.**>
* @param Resource activityExecution
* @param boolean evaluateValue
* @return core_kernel_classes_Resource
*/
public function getRestrictedUser(core_kernel_classes_Resource $activityExecution, $evaluateValue = true)
{
$returnValue = null;
$activityUser = $activityExecution->getOnePropertyValue($this->restrictedUserProperty);
if ($evaluateValue) {
if ($activityUser instanceof core_kernel_classes_Resource) {
$variableService = wfEngine_models_classes_VariableService::singleton();
if ($variableService->isProcessVariable($activityUser)) {
$actualValue = $activityExecution->getOnePropertyValue(new core_kernel_classes_Property($activityUser->getUri()));
if (!is_null($actualValue) && $actualValue instanceof core_kernel_classes_Resource) {
$returnValue = $actualValue;
}
} else {
//consider it as the role:
$returnValue = $activityUser;
}
}
} else {
$returnValue = $activityUser;
}
return $returnValue;
}
/**
* Short description of method getCardinality
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource activityCardinality
* @param Resource activityExecution
* @return mixed
*/
public function getCardinality(core_kernel_classes_Resource $activityCardinality, core_kernel_classes_Resource $activityExecution = null)
{
$returnValue = null;
//TODO: to be cached
if (!is_null($activityCardinality)) {
$variableService = wfEngine_models_classes_VariableService::singleton();
$cardinality = $activityCardinality->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_ACTIVITYCARDINALITY_CARDINALITY));
if ($cardinality instanceof core_kernel_classes_Literal && is_numeric((string) $cardinality)) {
$returnValue = intval((string) $cardinality);
} else {
if ($cardinality instanceof core_kernel_classes_Resource && $variableService->isProcessVariable($cardinality)) {
//consider it as a process variable:
if (is_null($activityExecution)) {
$returnValue = $cardinality;
} else {
//we want to retrieve the value in the context of execution
$cardinalityValue = $activityExecution->getOnePropertyValue(new core_kernel_classes_Property($cardinality->getUri()));
if ($cardinalityValue instanceof core_kernel_classes_Literal) {
$returnValue = intval((string) $cardinalityValue);
} else {
throw new wfEngine_models_classes_ProcessExecutionException('cardinality must be of a numeric type in a process variable');
}
}
} else {
throw new wfEngine_models_classes_ProcessDefinitonException('cardinality must be a integer or a process variable of an integer');
}
}
}
return $returnValue;
}
public function testCreateNotification()
{
$processDefinitionLabel = 'proc_def_label';
$processInstanceLabel = 'proc_inst_label';
$activity1Label = 'activity1';
$activity2Label = 'activity2';
$notificationMessage = '';
$processAuthoringService = wfAuthoring_models_classes_ProcessService::singleton();
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
$processVariableService = wfEngine_models_classes_VariableService::singleton();
//create some process variables:
$vars = array();
$varCodes = array('unitLabel', 'countryCode', 'languageCode');
foreach ($varCodes as $varCode) {
$vars[$varCode] = $processVariableService->getProcessVariable($varCode, true);
}
$spx = array();
$spxDefinition = array(VAR_PROCESS_INSTANCE => array(RDFS_LABEL), VAR_ACTIVITY_DEFINITION => array(RDFS_LABEL), VAR_ACTIVITY_INSTANCE => array(RDFS_LABEL, $vars['unitLabel']->getUri(), $vars['countryCode']->getUri(), $vars['languageCode']->getUri()), VAR_CURRENT_USER => array(RDFS_LABEL, PROPERTY_USER_FIRSTNAME, PROPERTY_USER_LASTNAME));
foreach ($spxDefinition as $contextUri => $predicates) {
$context = new core_kernel_classes_Resource($contextUri);
$spx[$contextUri] = array();
foreach ($predicates as $predicateUri) {
$term = $this->createSPX($context, new core_kernel_classes_Property($predicateUri));
$this->assertNotNull($term);
$spx[$contextUri][$predicateUri] = $term;
}
}
$notificationMessage = '
Dear {{' . $spx[VAR_CURRENT_USER][PROPERTY_USER_FIRSTNAME]->getUri() . '}} {{' . $spx[VAR_CURRENT_USER][PROPERTY_USER_LASTNAME]->getUri() . '}},
Please join the translation process of the unit {{' . $spx[VAR_ACTIVITY_INSTANCE][$vars['unitLabel']->getUri()]->getUri() . '}} to {{' . $spx[VAR_ACTIVITY_INSTANCE][$vars['languageCode']->getUri()]->getUri() . '}}_{{' . $spx[VAR_ACTIVITY_INSTANCE][$vars['countryCode']->getUri()]->getUri() . '}} to complete your next task "{{' . $spx[VAR_ACTIVITY_DEFINITION][RDFS_LABEL]->getUri() . '}}".
Bests,
The Workflow Engine
';
$processDefinition = $processAuthoringService->createProcess($processDefinitionLabel, 'create for notification service test case');
$this->assertNotNull($processDefinition);
$activity1 = $processAuthoringService->createActivity($processDefinition, $activity1Label);
$this->assertNotNull($processDefinition);
$this->assertTrue($processAuthoringService->setFirstActivity($processDefinition, $activity1));
$connector1 = $processAuthoringService->createConnector($activity1);
$this->assertNotNull($processDefinition);
$activity2 = $processAuthoringService->createSequenceActivity($connector1, null, $activity2Label);
$this->assertNotNull($activity2);
$this->service->bindProperties($connector1, array(PROPERTY_CONNECTORS_NOTIFY => INSTANCE_NOTIFY_USER, PROPERTY_CONNECTORS_USER_NOTIFIED => $this->currentUser->getUri(), PROPERTY_CONNECTORS_NOTIFICATION_MESSAGE => $notificationMessage));
$processExecution = $processExecutionService->createProcessExecution($processDefinition, $processInstanceLabel, 'created for the notification service test case', array($vars['unitLabel']->getUri() => 'myUnit', $vars['countryCode']->getUri() => 'FR', $vars['languageCode']->getUri() => 'fr'));
$this->assertNotNull($processExecution);
$activityExecs = $processExecutionService->getCurrentActivityExecutions($processExecution);
$this->assertEquals(count($activityExecs), 1);
$activityExecution = reset($activityExecs);
$activity = $activityExecutionService->getExecutionOf($activityExecution);
$this->assertEquals($activity->getUri(), $activity1->getUri());
//test notificaiton creation:
$notification = $this->service->createNotification($connector1, $this->currentUser, $activityExecution);
$this->assertNotNull($notification);
$builtMessage = (string) $notification->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_NOTIFICATION_MESSAGE));
$this->assertEquals($builtMessage, '
Dear Sammy Norville Rogers,
Please join the translation process of the unit myUnit to fr_FR to complete your next task "activity1".
Bests,
The Workflow Engine
');
foreach ($vars as $var) {
$var->delete();
}
foreach ($spx as $predicates) {
foreach ($predicates as $term) {
$term->delete();
}
}
$this->assertTrue($processExecutionService->deleteProcessExecution($processExecution));
$this->assertTrue($processAuthoringService->deleteProcess($processDefinition));
}
/**
* import either $leftPart or $rightpart given in $variable, $variable must be a variable
**/
private function importTermSPX($variable)
{
$termClass = new core_kernel_classes_Class(CLASS_TERM_SUJET_PREDICATE_X, __METHOD__);
//creates a Term
$termInstance = $termClass->createInstance("Term : SPX " . $variable, __(" generated by Condition Descriptor on ") . date(DATE_ISO8601));
$subjectProperty = new core_kernel_classes_Property(PROPERTY_TERM_SPX_SUBJET, __METHOD__);
$predicateProperty = new core_kernel_classes_Property(PROPERTY_TERM_SPX_PREDICATE, __METHOD__);
//get the resource with the code "$variable"
$processVariablesClass = new core_kernel_classes_Class(CLASS_PROCESSVARIABLES);
$processVariables = $processVariablesClass->searchInstances(array(PROPERTY_PROCESSVARIABLES_CODE => $variable), array('like' => false));
if (empty($processVariables)) {
//throw new common_Exception("the variable $variable doesn't exist, please create it before");//perform a check
common_Logger::i("the variable {$variable} doesn't exist, now it's created");
$variableService = wfEngine_models_classes_VariableService::singleton();
$tokenProperty = $variableService->createProcessVariable($variable, $variable);
} else {
$tokenProperty = array_shift($processVariables);
}
$termInstance->setPropertyValue($subjectProperty, VAR_PROCESS_INSTANCE);
$termInstance->setPropertyValue($predicateProperty, $tokenProperty->getUri());
return $termInstance;
}
/**
* Short description of method setProcessVariable
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource processDefinition
* @param string processVariable
* @return boolean
*/
public function setProcessVariable(core_kernel_classes_Resource $processDefinition, $processVariable)
{
$returnValue = (bool) false;
if (is_string($processVariable) && !empty($processVariable)) {
//is a code:
$variableService = wfEngine_models_classes_VariableService::singleton();
$processVariableResource = $variableService->getProcessVariable($processVariable);
if (!is_null($processVariableResource) && $processVariableResource instanceof core_kernel_classes_Resource) {
$returnValue = $processDefinition->setPropertyValue($this->processVariablesProp, $processVariableResource->getUri());
}
} elseif ($processVariable instanceof core_kernel_classes_Resource) {
$returnValue = $processDefinition->setPropertyValue($this->processVariablesProp, $processVariable->getUri());
}
return (bool) $returnValue;
}
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());
}
}
}
protected function setVariables($variables)
{
common_ext_ExtensionsManager::singleton()->getExtensionById('wfEngine')->load();
$variableService = wfEngine_models_classes_VariableService::singleton();
$cleaned = array();
foreach ($variables as $key => $value) {
$cleaned[$key] = is_object($value) && $value instanceof core_kernel_classes_Resource ? $value->getUri() : $value;
}
return $variableService->save($cleaned);
}
public function testCreateSequenceActivity()
{
$processDefinition = $this->proc;
$authoringService = $this->authoringService;
$processVariableService = wfEngine_models_classes_VariableService::singleton();
//set the required process variables subjectUri and wsdlContract
$var_map = $processVariableService->getProcessVariable("map", true);
$var_param1 = $processVariableService->getProcessVariable("param1", true);
$var_param2 = $processVariableService->getProcessVariable("param2", true);
//create formal param associated to the 3 required proc var:
$paramMap = $authoringService->getFormalParameter('map');
if (is_null($paramMap)) {
$paramMap = $authoringService->createFormalParameter('map', 'processvariable', $var_map->getUri(), 'label of the formal param "map"');
}
$param1 = $authoringService->getFormalParameter('param1');
if (is_null($param1)) {
$param1 = $authoringService->createFormalParameter('param1', 'processvariable', $var_param1->getUri(), 'label of the formal param "param1"');
}
$param2 = $authoringService->getFormalParameter('param2');
if (is_null($param2)) {
$param2 = $authoringService->createFormalParameter('param2', 'processvariable', $var_param2->getUri(), 'label of the formal param "param2"');
}
//creating the activity definition and connecting them sequentially:
$activityDefinitions = array();
//create an activity and set it as the first:
$activity1 = $authoringService->createActivity($processDefinition, 'activity1');
$this->assertNotNull($activity1);
$authoringService->setFirstActivity($processDefinition, $activity1);
$activityDefinitions[] = $activity1;
//create a connector to the first activity and set the type as "sequential"
$connector1 = null;
$connector1 = $authoringService->createConnector($activity1);
$authoringService->setConnectorType($connector1, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector1);
//same for the 2nd activity:
$activity2 = $authoringService->createSequenceActivity($connector1, null, 'activity2');
$connector2 = $authoringService->createConnector($activity2);
$authoringService->setConnectorType($connector2, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$activityDefinitions[] = $activity2;
//then the last:
$activity3 = $authoringService->createSequenceActivity($connector2, null, 'activity3');
$activityDefinitions[] = $activity3;
//the last activity does not have a connector
//set the service(i.e. unit) to each activity:
$services = array();
$services[1] = array('url' => 'url of unit1', 'label' => 'label of unit1');
$services[2] = array('url' => 'url of unit2', 'label' => 'label of unit2');
$services[3] = array('url' => 'url of unit3', 'label' => 'label of unit3');
$i = 1;
$serviceDefinitions = array();
foreach ($activityDefinitions as $activity) {
$url_unit = $services[$i]['url'];
$label_unit = $services[$i]['label'];
//try to find if a service definiton has already been created for the unit:
$serviceDefinition = null;
$serviceDefinitionClass = new core_kernel_classes_Class(CLASS_SUPPORTSERVICES);
$foundServiceDefinitions = $serviceDefinitionClass->searchInstances(array(PROPERTY_SUPPORTSERVICES_URL => $url_unit), array('like' => false));
if (!empty($foundServiceDefinitions)) {
$serviceDefinition = array_shift($foundServiceDefinitions);
}
if (is_null($serviceDefinition)) {
//if no corresponding service def found, create a service definition:
$serviceDefinition = $serviceDefinitionClass->createInstance($label_unit, 'created by process map testcase');
//set service definition (the unit) and parameters:
$serviceDefinition->setPropertyValue(new core_kernel_classes_Property(PROPERTY_SUPPORTSERVICES_URL), $url_unit);
$serviceDefinition->setPropertyValue(new core_kernel_classes_Property(PROPERTY_SERVICESDEFINITION_FORMALPARAMIN), $paramMap->getUri());
$serviceDefinition->setPropertyValue(new core_kernel_classes_Property(PROPERTY_SERVICESDEFINITION_FORMALPARAMIN), $param1->getUri());
$serviceDefinition->setPropertyValue(new core_kernel_classes_Property(PROPERTY_SERVICESDEFINITION_FORMALPARAMIN), $param2->getUri());
$serviceDefinitions[$serviceDefinition->getUri()] = $serviceDefinition;
}
$this->assertNotNull($serviceDefinition);
//create a call of service and associate the service definition to it:
$service = $authoringService->createInteractiveService($activity);
$service->setPropertyValue(new core_kernel_classes_Property(PROPERTY_CALLOFSERVICES_SERVICEDEFINITION), $serviceDefinition->getUri());
$authoringService->setActualParameter($service, $paramMap, $var_map->getUri(), PROPERTY_CALLOFSERVICES_ACTUALPARAMETERIN, PROPERTY_ACTUALPARAMETER_PROCESSVARIABLE);
$authoringService->setActualParameter($service, $param1, $var_param1->getUri(), PROPERTY_CALLOFSERVICES_ACTUALPARAMETERIN, PROPERTY_ACTUALPARAMETER_PROCESSVARIABLE);
$authoringService->setActualParameter($service, $param2, $var_param2->getUri(), PROPERTY_CALLOFSERVICES_ACTUALPARAMETERIN, PROPERTY_ACTUALPARAMETER_PROCESSVARIABLE);
$this->assertNotNull($service);
$i++;
}
//end of process definition creation
//get the ordered list of activity of the sequential process:
$activityList = array();
//get list of all activities:
$activities = $authoringService->getActivitiesByProcess($processDefinition);
$totalNumber = count($activities);
//find the first one: property isinitial == true (must be only one, if not error) and set as the currentActivity:
$currentActivity = null;
foreach ($activities as $activity) {
$isIntial = $activity->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISINITIAL));
if (!is_null($isIntial) && $isIntial instanceof core_kernel_classes_Resource) {
if ($isIntial->getUri() == GENERIS_TRUE) {
$currentActivity = $activity;
break;
}
}
}
$this->assertNotNull($currentActivity);
//start the loop:
for ($i = 0; $i < $totalNumber; $i++) {
//set the test in the table:
$activityList[$i] = $currentActivity;
//get its connector (check the type is "sequential) if ok, get the next activity
$connectors = $currentActivity->getPropertyValues(new core_kernel_classes_Property(PROPERTY_STEP_NEXT));
$nextActivity = null;
foreach ($connectors as $connectorUri) {
$connector = new core_kernel_classes_Resource($connectorUri);
$connectorType = $connector->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_TYPE));
if ($connectorType->getUri() == INSTANCE_TYPEOFCONNECTORS_SEQUENCE) {
$nextActivity = $connector->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_STEP_NEXT));
break;
}
}
if (!is_null($nextActivity)) {
$currentActivity = $nextActivity;
} else {
if ($i == $totalNumber - 1) {
//it is normal, since it is the last activity and test
} else {
throw new Exception('the next activity of the connector is not found');
}
}
}
$this->assertEquals(count($activityList), 3);
//delete all created resources:
$var_map->delete();
$var_param1->delete();
$var_param2->delete();
$paramMap->delete();
$param1->delete();
$param2->delete();
foreach ($serviceDefinitions as $serviceDefinition) {
$serviceDefinition->delete();
}
}
/**
* 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])) {
if (isset($this->data[$rowId][$columnId])) {
$returnValue = $this->data[$rowId][$columnId];
}
} else {
if (common_Utils::isUri($rowId)) {
$this->data[$rowId] = array();
$activityExecution = new core_kernel_classes_Resource($rowId);
$activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
$processVariableService = wfEngine_models_classes_VariableService::singleton();
$unit = $processVariableService->get('unitUri', $activityExecution);
$countryCode = (string) $processVariableService->get('countryCode', $activityExecution);
$languageCode = (string) $processVariableService->get('languageCode', $activityExecution);
if ($unit instanceof core_kernel_classes_Resource && !empty($countryCode) && !empty($languageCode)) {
$activity = $activityExecutionService->getExecutionOf($activityExecution);
//check if it is the translation activity or not:
$xliff = null;
$vff = null;
if ($activity->getLabel() == 'Translate') {
$xliffWorkingProperty = $this->getTranslationFileProperty('xliff_working', $countryCode, $languageCode);
if (!is_null($xliffWorkingProperty)) {
$xliff = $unit->getOnePropertyValue($xliffWorkingProperty);
}
$vffWorkingProperty = $this->getTranslationFileProperty('vff_working', $countryCode, $languageCode);
if (!is_null($vffWorkingProperty)) {
$vff = $unit->getOnePropertyValue($vffWorkingProperty);
}
} else {
$xliffProperty = $this->getTranslationFileProperty('xliff', $countryCode, $languageCode);
if (!is_null($xliffProperty)) {
$xliff = $unit->getOnePropertyValue($xliffProperty);
}
$vffProperty = $this->getTranslationFileProperty('vff', $countryCode, $languageCode);
if (!is_null($vffProperty)) {
$vff = $unit->getOnePropertyValue($vffProperty);
}
}
if ($xliff instanceof core_kernel_classes_Resource) {
$xliff = new core_kernel_versioning_File($xliff);
$this->data[$rowId]['xliff'] = $xliff->getUri();
$this->data[$rowId]['xliff_version'] = (string) $processVariableService->get('xliff', $activityExecution);
} else {
$this->data[$rowId]['xliff'] = 'n/a';
$this->data[$rowId]['xliff_version'] = 'n/a';
}
if ($vff instanceof core_kernel_classes_Resource) {
$vff = new core_kernel_versioning_File($vff);
$this->data[$rowId]['vff'] = $vff->getUri();
$this->data[$rowId]['vff_version'] = (string) $processVariableService->get('vff', $activityExecution);
} else {
$this->data[$rowId]['vff'] = 'n/a';
$this->data[$rowId]['vff_version'] = 'n/a';
}
} else {
$this->data[$rowId] = array('xliff' => 'n/a', 'xliff_version' => 'n/a', 'vff' => 'n/a', 'vff_version' => 'n/a');
}
if (isset($this->data[$rowId][$columnId])) {
$returnValue = $this->data[$rowId][$columnId];
}
}
}
return $returnValue;
}
private function executeServicePositionVariable($variableCode, $ok, $msg)
{
$returnValue = false;
$this->out($msg, true);
$processVariableService = wfEngine_models_classes_VariableService::singleton();
$variable = $processVariableService->getProcessVariable($variableCode);
if (!is_null($variable)) {
$returnValue = $processVariableService->edit($variableCode, (bool) $ok ? 1 : 0);
} else {
throw new Exception("the process variable with the code {$variableCode} does not exist");
}
return $returnValue;
}
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->processMonitoringGridOptions = array('columns' => array(RDFS_LABEL => array('weight' => 3), PROPERTY_PROCESSINSTANCES_EXECUTIONOF => array('weight' => 2), PROPERTY_PROCESSINSTANCES_CURRENTACTIVITYEXECUTIONS => array('weight' => 6, 'widget' => 'CurrentActivities', 'columns' => array('variables' => array('widget' => 'ActivityVariables', 'columns' => array('value' => array('weight' => 3, 'widget' => 'ActivityVariable')))))));
$this->variableService = wfEngine_models_classes_VariableService::singleton();
}
/**
* Short description of method createServiceDefinition
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param string label
* @param string serviceUrl
* @param array inputParameters
* @return core_kernel_classes_Resource
*/
public function createServiceDefinition($label = '', $serviceUrl = '', $inputParameters = array())
{
$returnValue = null;
if (!empty($serviceUrl)) {
$supportServiceClass = new core_kernel_classes_Class(CLASS_SUPPORTSERVICES);
if (empty($label)) {
$label = $this->createUniqueLabel($supportServiceClass);
}
$returnValue = $supportServiceClass->createInstance($label, 'service definition created for the unit test of process execution');
$returnValue->setPropertyValue(new core_kernel_classes_Property(PROPERTY_SUPPORTSERVICES_URL), $serviceUrl);
//add management of wsdl service
$propFormalParam = new core_kernel_classes_Property(PROPERTY_SERVICESDEFINITION_FORMALPARAMIN);
$classFormalParam = new core_kernel_classes_Class(CLASS_FORMALPARAMETER);
$classProcessVariables = new core_kernel_classes_Class(CLASS_PROCESSVARIABLES);
$variableService = wfEngine_models_classes_VariableService::singleton();
foreach ($inputParameters as $paramName => $value) {
$formalParam = null;
$formalParam = $this->getFormalParameter($paramName, $value);
if (is_null($formalParam)) {
//create one:
$defaultValue = '';
$defaultValueType = 'constant';
if (is_string($value)) {
$value = trim($value);
if (!empty($value)) {
if (substr($value, 0, 1) == '^') {
//is a process var, so get related process var resource:
$code = substr($value, 1);
$processVar = $variableService->getProcessVariable($code);
if (is_null($processVar)) {
$processVar = $variableService->createProcessVariable($code, $code);
}
if (!is_null($processVar)) {
$defaultValue = $processVar->getUri();
$defaultValueType = 'processvariable';
} else {
throw new Exception('cannot create process variable with the code ' . $code);
}
} else {
//it is a constant
$defaultValue = $value;
}
}
} else {
if ($value instanceof core_kernel_classes_Resource) {
//check if it is a process variable:
if ($value->hasType($classProcessVariables)) {
$defaultValue = $value->getUri();
$defaultValueType = 'processvariable';
}
}
}
$formalParam = $this->createFormalParameter($paramName, $defaultValueType, $defaultValue, $paramName);
}
if (!is_null($formalParam)) {
$returnValue->setPropertyValue($propFormalParam, $formalParam->getUri());
}
}
}
return $returnValue;
}
/**
* Short description of method connectorNode
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource connector
* @param string nodeClass
* @param boolean recursive
* @return array
*/
public function connectorNode(core_kernel_classes_Resource $connector, $nodeClass = '', $recursive = false)
{
$returnValue = array();
$connectorData = array();
$connectorService = wfEngine_models_classes_ConnectorService::singleton();
// $activityService = wfEngine_models_classes_ActivityService::singleton();
//type of connector:
//if not null, get the information on the next activities. Otherwise, return an "empty" connector node, indicating that the node has just been created, i.e. at the same time as an activity
$connectorType = $connector->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_TYPE), false);
if (is_null($connectorType)) {
//create default connector node:
$returnValue = $this->addNodePrefix($this->defaultConnectorNode($connector), $nodeClass);
return $returnValue;
} else {
//if it is a conditional type
if ($connectorType->getUri() == INSTANCE_TYPEOFCONNECTORS_CONDITIONAL) {
//get the rule
$connectorRule = $connector->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_TRANSITIONRULE), false);
if (!is_null($connectorRule)) {
//continue getting connector data:
$connectorData[] = $this->conditionNode($connectorRule);
//get the "THEN"
$then = $connectorRule->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_TRANSITIONRULES_THEN), false);
if (!is_null($then)) {
$portData = array('id' => 0, 'label' => 'then', 'multiplicity' => 1);
if ($connectorService->isConnector($then)) {
$connectorActivityReference = $then->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_ACTIVITYREFERENCE))->getUri();
if ($connectorActivityReference == $this->currentActivity->getUri() && !in_array($then->getUri(), $this->addedConnectors)) {
if ($recursive) {
$connectorData[] = $this->connectorNode($then, 'then', true, $portData);
} else {
$connectorData[] = $this->activityNode($then, 'then', false, $portData);
}
} else {
$connectorData[] = $this->activityNode($then, 'then', true, $portData);
}
} else {
$connectorData[] = $this->activityNode($then, 'then', true, $portData);
}
}
//same for the "ELSE"
$else = $connectorRule->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_TRANSITIONRULES_ELSE), false);
if (!is_null($else)) {
$portData = array('id' => 1, 'label' => 'else', 'multiplicity' => 1);
if ($connectorService->isConnector($else)) {
$connectorActivityReference = $else->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_ACTIVITYREFERENCE))->getUri();
if ($connectorActivityReference == $this->currentActivity->getUri() && !in_array($else->getUri(), $this->addedConnectors)) {
if ($recursive) {
$connectorData[] = $this->connectorNode($else, 'else', true, $portData);
} else {
$connectorData[] = $this->activityNode($else, 'else', false, $portData);
}
} else {
$connectorData[] = $this->activityNode($else, 'else', true, $portData);
}
} else {
$connectorData[] = $this->activityNode($else, 'else', true, $portData);
}
}
}
} elseif ($connectorType->getUri() == INSTANCE_TYPEOFCONNECTORS_SEQUENCE) {
$next = $connector->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_STEP_NEXT), false);
if (!is_null($next)) {
$connectorData[] = $this->activityNode($next, 'next', true);
//the default portData array will do
}
} elseif ($connectorType->getUri() == INSTANCE_TYPEOFCONNECTORS_PARALLEL) {
$cardinalityService = wfEngine_models_classes_ActivityCardinalityService::singleton();
$variableService = wfEngine_models_classes_VariableService::singleton();
$nextActivitiesCollection = $connector->getPropertyValuesCollection(new core_kernel_classes_Property(PROPERTY_STEP_NEXT));
$portId = 0;
foreach ($nextActivitiesCollection->getIterator() as $nextActivity) {
if ($cardinalityService->isCardinality($nextActivity)) {
$activity = $cardinalityService->getDestination($nextActivity);
$cardinality = $cardinalityService->getCardinality($nextActivity);
$number = $cardinality instanceof core_kernel_classes_Resource ? '^' . $variableService->getCode($cardinality) : $cardinality;
$connectorData[] = $this->activityNode($activity, 'next', true, array('id' => $portId, 'multiplicity' => $number, 'label' => $activity->getLabel()), "(count : {$number})");
$portId++;
}
}
} elseif ($connectorType->getUri() == INSTANCE_TYPEOFCONNECTORS_JOIN) {
$next = $connector->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_STEP_NEXT), false);
if (!is_null($next)) {
$connectorData[] = $this->activityNode($next, 'next', true);
//the default portData array will do
}
} else {
throw new Exception("unknown connector type: {$connectorType->getLabel()} for connector {$connector->getUri()}");
}
if (empty($portInfo)) {
$portInfo = array('id' => 0, 'label' => 'next', 'multiplicity' => 1);
} else {
if (!isset($portInfo['id'])) {
$portInfo['id'] = 0;
}
if (!isset($portInfo['id'])) {
$portInfo['label'] = 'next';
}
if (!isset($portInfo['id'])) {
$portInfo['multiplicity'] = 1;
}
}
//add to data
$returnValue = array('data' => $connectorType->getLabel() . ":" . $connector->getLabel(), 'attributes' => array('id' => tao_helpers_Uri::encode($connector->getUri()), 'class' => 'node-connector'), 'type' => trim(strtolower($connectorType->getLabel())), 'port' => $nodeClass, 'portData' => $portInfo);
$returnValue = self::addNodePrefix($returnValue, $nodeClass);
if (!empty($connectorData)) {
$returnValue['children'] = $connectorData;
}
$this->addedConnectors[] = $connector->getUri();
}
return (array) $returnValue;
}
/**
* Test the sequential process execution:
*/
public function testVirtualSequencialProcess()
{
error_reporting(E_ALL);
try {
$roleService = wfEngine_models_classes_RoleService::singleton();
$authoringService = wfAuthoring_models_classes_ProcessService::singleton();
$activityService = wfEngine_models_classes_ActivityService::singleton();
$activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$processVariableService = wfEngine_models_classes_VariableService::singleton();
//TEST PLAN :
//INSTANCE_ACL_ROLE, $roleA
//INSTANCE_ACL_ROLE_RESTRICTED_USER, $roleB
//INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB (assigned dynamically via process var $role_processVar in activity1)
//INSTANCE_ACL_USER, $user2 (assigned dynamically via process var $user_processVar in activity2)
//INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB (assigned dynamically via process var $role_processVar in activity1)
//INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY, $roleA
//create roles and users:
$wfRole = new core_kernel_classes_Resource(INSTANCE_ROLE_WORKFLOW);
$roleA = $roleService->addRole('ACLTestCaseRoleA', $wfRole);
$roleB = $roleService->addRole('ACLTestCaseRoleB', $wfRole);
$roleC = $roleService->addRole('ACLTestCaseRoleC', $wfRole);
list($usec, $sec) = explode(" ", microtime());
$users = array();
$users[0] = $usec;
for ($i = 1; $i <= 6; $i++) {
$users[] = 'ACLTestCaseUser' . $i . '-' . $usec;
}
$user1 = $this->createUser($users[1]);
$user1->setLabel($users[1]);
$user2 = $this->createUser($users[2]);
$user2->setLabel($users[2]);
$user3 = $this->createUser($users[3]);
$user3->setLabel($users[3]);
$user4 = $this->createUser($users[4]);
$user4->setLabel($users[4]);
$user5 = $this->createUser($users[5]);
$user5->setLabel($users[5]);
$user6 = $this->createUser($users[6]);
$user6->setLabel($users[6]);
$roleService->setRoleToUsers($roleA, array($user1->getUri(), $user2->getUri(), $user3->getUri()));
$roleService->setRoleToUsers($roleB, array($user4->getUri(), $user5->getUri()));
$roleService->setRoleToUsers($roleC, array($user6->getUri()));
//create some process variables:
$user_processVar_key = 'unit_var_user_' . time();
$user_processVar = $processVariableService->createProcessVariable('Proc Var for user assignation', $user_processVar_key);
$role_processVar_key = 'unit_var_role_' . time();
$role_processVar = $processVariableService->createProcessVariable('Proc Var for role assignation', $role_processVar_key);
//create a new process def
$processDefinition = $authoringService->createProcess('ProcessForUnitTest', 'Unit test');
$this->assertIsA($processDefinition, 'core_kernel_classes_Resource');
//define activities and connectors
//activity 1:
$activity1 = $authoringService->createActivity($processDefinition, 'activity1');
$this->assertNotNull($activity1);
$authoringService->setFirstActivity($processDefinition, $activity1);
$activityService->setAcl($activity1, new core_kernel_classes_Resource(INSTANCE_ACL_ROLE), $roleA);
$connector1 = $authoringService->createConnector($activity1);
$authoringService->setConnectorType($connector1, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector1);
//activity 2:
$activity2 = $authoringService->createSequenceActivity($connector1, null, 'activity2');
$this->assertNotNull($activity2);
$activityService->setAcl($activity2, new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER), $roleB);
$connector2 = $authoringService->createConnector($activity2);
$authoringService->setConnectorType($connector2, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector2);
//activity 3:
$activity3 = $authoringService->createSequenceActivity($connector2, null, 'activity3');
$this->assertNotNull($activity3);
$activityService->setAcl($activity3, new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED), $role_processVar);
$connector3 = $authoringService->createConnector($activity3);
$authoringService->setConnectorType($connector3, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector3);
//activity 4:
$activity4 = $authoringService->createSequenceActivity($connector3, null, 'activity4');
$this->assertNotNull($activity4);
$activityService->setAcl($activity4, new core_kernel_classes_Resource(INSTANCE_ACL_USER), $user_processVar);
$connector4 = $authoringService->createConnector($activity4);
$authoringService->setConnectorType($connector4, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector4);
//activity 5:
$activity5 = $authoringService->createSequenceActivity($connector4, null, 'activity5');
$this->assertNotNull($activity5);
$activityService->setAcl($activity5, new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED), $role_processVar);
$connector5 = $authoringService->createConnector($activity5);
$authoringService->setConnectorType($connector5, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector5);
//activity 6:
$activity6 = $authoringService->createSequenceActivity($connector5, null, 'activity6');
$this->assertNotNull($activity6);
$activityService->setAcl($activity6, new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY), $roleA);
//run the process
$processExecName = 'Test Process Execution';
$processExecComment = 'created for processExecustionService test case by ' . __METHOD__;
$processInstance = $processExecutionService->createProcessExecution($processDefinition, $processExecName, $processExecComment);
$this->assertEquals($processDefinition->getUri(), $processExecutionService->getExecutionOf($processInstance)->getUri());
$this->assertEquals($processDefinition->getUri(), $processExecutionService->getExecutionOf($processInstance)->getUri());
$this->assertTrue($processExecutionService->checkStatus($processInstance, 'started'));
$this->out(__METHOD__, true);
$currentActivityExecutions = $processExecutionService->getCurrentActivityExecutions($processInstance);
$this->assertEquals(count($currentActivityExecutions), 1);
$this->assertEquals(strpos(array_pop($currentActivityExecutions)->getLabel(), 'Execution of activity1'), 0);
$this->out("<strong>Forward transitions:</strong>", true);
$loginProperty = new core_kernel_classes_Property(PROPERTY_USER_LOGIN);
$iterationNumber = 6;
$i = 1;
while ($i <= $iterationNumber) {
if ($i < $iterationNumber) {
//try deleting a process that is not finished
$this->assertFalse($processExecutionService->deleteProcessExecution($processInstance, true));
}
$activities = $processExecutionService->getAvailableCurrentActivityDefinitions($processInstance, $this->currentUser);
$this->assertEquals(count($activities), 1);
$activity = array_shift($activities);
$this->out("<strong>" . $activity->getLabel() . "</strong>", true);
$this->assertTrue($activity->getLabel() == 'activity' . $i);
$this->out("current user : "******"' . $this->currentUser->getUri() . '"', true);
$activityExecutions = $processExecutionService->getCurrentActivityExecutions($processInstance);
$activityExecution = reset($activityExecutions);
$this->checkAccessControl($activityExecution);
//check ACL:
switch ($i) {
case 1:
//INSTANCE_ACL_ROLE, $roleA:
$this->checkAclRole($users, $activityExecution, $processInstance);
$processVariableService->push($role_processVar_key, $roleB->getUri());
break;
case 2:
//INSTANCE_ACL_ROLE_RESTRICTED_USER, $roleB:
$this->checkAclRoleRestrictedUser($users, $activityExecution, $processInstance);
$processVariableService->push($user_processVar_key, $user2->getUri());
break;
case 3:
//INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB
$this->assertTrue($this->changeUser($users[5]));
$this->assertTrue($activityExecutionService->checkAcl($activityExecution, $this->currentUser, $processInstance));
$this->assertNotNull($processExecutionService->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser));
$this->checkAclRoleRestrictedUserInherited($users, $activityExecution, $processInstance);
break;
case 4:
//INSTANCE_ACL_USER, $user2:
$this->checkAclUser($users, $activityExecution, $processInstance);
break;
case 5:
//INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB:
//only user5 can access it normally:
$this->checkUser5($users, $activityExecution, $processInstance);
break;
case 6:
//INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY, $roleA:
//only the user of $roleA that executed (the initial acivity belongs to user2:
$this->checkAclRoleRestrictedUserDelivery($users, $activityExecution, $processInstance);
break;
}
//init execution
$activityExecution = $processExecutionService->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser);
$this->assertNotNull($activityExecution);
$activityExecStatus = $activityExecutionService->getStatus($activityExecution);
$this->assertNotNull($activityExecStatus);
$this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED);
//transition to next activity
$transitionResult = $processExecutionService->performTransition($processInstance, $activityExecution);
switch ($i) {
case 1:
case 3:
case 4:
case 5:
$this->assertFalse(count($transitionResult) > 0);
$this->assertTrue($processExecutionService->isPaused($processInstance));
break;
case 2:
$this->assertTrue(count($transitionResult) > 0);
$this->assertFalse($processExecutionService->isPaused($processInstance));
break;
case 6:
$this->assertFalse(count($transitionResult) > 0);
$this->assertTrue($processExecutionService->isFinished($processInstance));
break;
}
$this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel());
$this->out("process status: " . $processExecutionService->getStatus($processInstance)->getLabel());
$i++;
}
$this->assertTrue($processExecutionService->isFinished($processInstance));
$this->assertTrue($processExecutionService->resume($processInstance));
$this->out("<strong>Backward transitions:</strong>", true);
$j = 0;
while ($j < $iterationNumber) {
$activitieExecs = $processExecutionService->getCurrentActivityExecutions($processInstance);
$this->assertEquals(count($activitieExecs), 1);
$activityExecution = reset($activitieExecs);
$activity = $activityExecutionService->getExecutionOf($activityExecution);
$this->out("<strong>" . $activity->getLabel() . "</strong>", true);
$index = $iterationNumber - $j;
$this->assertEquals($activity->getLabel(), "activity{$index}");
$this->out("current user : "******"' . $this->currentUser->getUri() . '"', true);
$this->checkAccessControl($activityExecution);
//check ACL:
switch ($index) {
case 1:
//INSTANCE_ACL_ROLE, $roleA:
$this->checkAclRole($users, $activityExecution, $processInstance);
break;
case 2:
//INSTANCE_ACL_ROLE_RESTRICTED_USER, $roleB:
$this->checkAclRoleRestrictedUser($users, $activityExecution, $processInstance);
break;
case 3:
//INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB
$this->checkAclRoleRestrictedUserInherited($users, $activityExecution, $processInstance);
break;
case 4:
//INSTANCE_ACL_USER, $user2:
$this->checkAclUser($users, $activityExecution, $processInstance);
break;
case 5:
//INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB:
//only user5 can access it normally:
$this->checkUser5($users, $activityExecution, $processInstance);
break;
case 6:
//INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY, $roleA:
//only the user of $roleA that executed (the initial acivity belongs to user2:
$this->checkAclRoleRestrictedUserDelivery($users, $activityExecution, $processInstance);
break;
}
//init execution
$activityExecution = $processExecutionService->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser);
$this->assertNotNull($activityExecution);
$activityExecStatus = $activityExecutionService->getStatus($activityExecution);
$this->assertNotNull($activityExecStatus);
$this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED);
//transition to next activity
$transitionResult = $processExecutionService->performBackwardTransition($processInstance, $activityExecution);
$processStatus = $processExecutionService->getStatus($processInstance);
$this->assertNotNull($processStatus);
$this->assertEquals($processStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED);
if ($j < $iterationNumber - 1) {
$this->assertTrue(count($transitionResult) > 0);
} else {
$this->assertFalse($transitionResult);
}
$this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel());
$this->out("process status: " . $processExecutionService->getStatus($processInstance)->getLabel());
$j++;
}
$this->out("<strong>Forward transitions again:</strong>", true);
$i = 1;
while ($i <= $iterationNumber) {
if ($i < $iterationNumber) {
//try deleting a process that is not finished
$this->assertFalse($processExecutionService->deleteProcessExecution($processInstance, true));
}
$activitieExecs = $processExecutionService->getCurrentActivityExecutions($processInstance);
$this->assertEquals(count($activitieExecs), 1);
$activityExecution = reset($activitieExecs);
$activity = $activityExecutionService->getExecutionOf($activityExecution);
$this->out("<strong>" . $activity->getLabel() . "</strong>", true);
$this->assertTrue($activity->getLabel() == 'activity' . $i);
$this->checkAccessControl($activityExecution);
//check ACL:
switch ($i) {
case 1:
//INSTANCE_ACL_ROLE, $roleA:
$this->checkAclRole($users, $activityExecution, $processInstance);
//TODO:to be modified after "back"
$processVariableService->push($role_processVar_key, $roleB->getUri());
break;
case 2:
//INSTANCE_ACL_ROLE_RESTRICTED_USER, $roleB:
$this->checkAclRoleRestrictedUser($users, $activityExecution, $processInstance);
//TODO:to be modified after "back"
$processVariableService->push($user_processVar_key, $user2->getUri());
break;
case 3:
//INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB
$this->checkAclRoleRestrictedUserInherited($users, $activityExecution, $processInstance);
break;
case 4:
//INSTANCE_ACL_USER, $user2:
$this->checkAclUser($users, $activityExecution, $processInstance);
break;
case 5:
//INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB:
//only user5 can access it normally:
$this->checkUser5($users, $activityExecution, $processInstance);
break;
case 6:
//INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY, $roleA:
//only the user of $roleA that executed (the initial acivity belongs to user2:
$this->checkAclRoleRestrictedUserDelivery($users, $activityExecution, $processInstance);
break;
}
//init execution
$activityExecution = $processExecutionService->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser);
$this->assertNotNull($activityExecution);
//transition to next activity
$transitionResult = $processExecutionService->performTransition($processInstance, $activityExecution);
switch ($i) {
case 1:
case 3:
case 4:
case 5:
$this->assertFalse(count($transitionResult) > 0);
$this->assertTrue($processExecutionService->isPaused($processInstance));
break;
case 2:
$this->assertTrue(count($transitionResult) > 0);
$this->assertFalse($processExecutionService->isPaused($processInstance));
break;
case 6:
$this->assertFalse(count($transitionResult) > 0);
$this->assertTrue($processExecutionService->isFinished($processInstance));
break;
}
$this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel());
$this->out("process status: " . $processExecutionService->getStatus($processInstance)->getLabel());
$i++;
}
$this->assertTrue($processExecutionService->isFinished($processInstance));
//delete processdef:
$this->assertTrue($authoringService->deleteProcess($processDefinition));
//delete process execution:
$this->assertTrue($processInstance->exists());
$this->assertTrue($processExecutionService->deleteProcessExecution($processInstance));
$this->assertFalse($processInstance->exists());
if (!is_null($this->currentUser)) {
$this->userService->logout();
$this->userService->removeUser($this->currentUser);
}
$roleA->delete();
$roleB->delete();
$roleC->delete();
$user1->delete();
$user2->delete();
$user3->delete();
$user4->delete();
$user5->delete();
$user6->delete();
$user_processVar->delete();
$role_processVar->delete();
} catch (common_Exception $ce) {
$this->fail($ce);
}
}
