public function __construct($options = array())
{
common_user_auth_Service::singleton()->startSession(new core_kernel_users_GenerisUser(new core_kernel_classes_Resource(TAO_INSTALLATOR)));
$this->processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$this->localNS = common_ext_NamespaceManager::singleton()->getLocalNamespace()->getUri();
$this->unserialize = isset($options['unserialize']) ? (int) $options['unserialize'] : 0;
}
/**
* Short description of method __construct
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource processExecution
* @param array options
* @return boolean
*/
public function __construct(core_kernel_classes_Resource $processExecution, $options = array())
{
$returnValue = (bool) false;
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$this->activityExecutions = $processExecutionService->getExecutionHistory($processExecution);
parent::__construct($this->activityExecutions, $options);
return (bool) $returnValue;
}
/**
* Short description of method getSubgridRows
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param string rowId
* @return array
*/
public function getSubgridRows($rowId)
{
$returnValue = array();
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$processInstance = new core_kernel_classes_Resource($rowId);
$currentActivityExecutions = $processExecutionService->getCurrentActivityExecutions($processInstance);
$returnValue = array_keys($currentActivityExecutions);
return (array) $returnValue;
}
public function __construct()
{
parent::__construct();
$this->processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$this->activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
//validate ALL posted values:
$processExecutionUri = urldecode($this->getRequestParameter('processExecutionUri'));
if (!empty($processExecutionUri) && common_Utils::isUri($processExecutionUri)) {
$this->processExecution = new core_kernel_classes_Resource($processExecutionUri);
}
$activityExecutionUri = urldecode($this->getRequestParameter('activityExecutionUri'));
if (!empty($activityExecutionUri) && common_Utils::isUri($activityExecutionUri)) {
$this->activityExecution = new core_kernel_classes_Resource($activityExecutionUri);
}
$this->setSuccess(false);
}
public function initProcessExecution($posted)
{
//set_time_limit(200);
helpers_TimeOutHelper::setTimeOutLimit(helpers_TimeOutHelper::LONG);
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
$processDefinitionUri = urldecode($posted['executionOf']);
$processDefinition = new core_kernel_classes_Resource($processDefinitionUri);
$processExecName = $posted["variables"][RDFS_LABEL];
$processExecComment = 'Created in Processes server on ' . date(DATE_ISO8601);
$processVariables = $posted["variables"];
$newProcessExecution = $processExecutionService->createProcessExecution($processDefinition, $processExecName, $processExecComment, $processVariables);
//create nonce to initial activity executions:
foreach ($processExecutionService->getCurrentActivityExecutions($newProcessExecution) as $initialActivityExecution) {
$activityExecutionService->createNonce($initialActivityExecution);
}
helpers_TimeOutHelper::reset();
$param = array('processUri' => urlencode($newProcessExecution->getUri()));
$this->redirect(tao_helpers_Uri::url('index', 'ProcessBrowser', null, $param));
}
public function __construct()
{
parent::__construct();
$this->processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$this->activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
//validate ALL posted values:
$processExecutionUri = urldecode($this->getRequestParameter('processUri'));
if (!empty($processExecutionUri) && common_Utils::isUri($processExecutionUri)) {
$processExecution = new core_kernel_classes_Resource($processExecutionUri);
//check that the process execution is not finished or closed here:
if ($this->processExecutionService->isFinished($processExecution)) {
common_Logger::w('Cannot browse a finished process execution');
$this->redirectToMain();
} else {
$this->processExecution = $processExecution;
$activityExecutionUri = urldecode($this->getRequestParameter('activityUri'));
if (!empty($activityExecutionUri) && common_Utils::isUri($activityExecutionUri)) {
$activityExecution = new core_kernel_classes_Resource($activityExecutionUri);
$currentActivityExecutions = $this->processExecutionService->getCurrentActivityExecutions($this->processExecution);
//check if it is a current activity exec:
if (array_key_exists($activityExecutionUri, $currentActivityExecutions)) {
$this->activityExecution = $activityExecution;
//if ok, check the nonce:
$nc = $this->getRequestParameter('nc');
if ($this->activityExecutionService->checkNonce($this->activityExecution, $nc)) {
$this->activityExecutionNonce = true;
} else {
$this->activityExecutionNonce = false;
}
} else {
//the provided activity execution is no longer the current one (link may be outdated).
//the user is redirected to the current activity execution if allowed,
//or redirected to "main" if there are more than one allowed current activity execution or none
common_Logger::w('The provided activity execution is no longer the current one');
$this->autoRedirecting = true;
}
}
}
}
}
/**
* 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 {
if (common_Utils::isUri($rowId)) {
$excludedProperties = is_array($this->options) && isset($this->options['excludedProperties']) ? $this->options['excludedProperties'] : array();
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$processInstance = new core_kernel_classes_Resource($rowId);
$this->data[$rowId] = array();
if (!in_array(RDFS_LABEL, $excludedProperties)) {
$this->data[$rowId][RDFS_LABEL] = $processInstance->getLabel();
}
if (!in_array(PROPERTY_PROCESSINSTANCES_STATUS, $excludedProperties)) {
$status = $processExecutionService->getStatus($processInstance);
$this->data[$rowId][PROPERTY_PROCESSINSTANCES_STATUS] = is_null($status) ? 'n/a' : $status->getLabel();
}
if (!in_array(PROPERTY_PROCESSINSTANCES_EXECUTIONOF, $excludedProperties)) {
$executionOf = $processExecutionService->getExecutionOf($processInstance);
$this->data[$rowId][PROPERTY_PROCESSINSTANCES_EXECUTIONOF] = is_null($executionOf) ? 'n/a' : $executionOf->getLabel();
}
if (!in_array(PROPERTY_PROCESSINSTANCES_TIME_STARTED, $excludedProperties)) {
$time = (string) $processInstance->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_PROCESSINSTANCES_TIME_STARTED));
$this->data[$rowId][PROPERTY_PROCESSINSTANCES_TIME_STARTED] = !empty($time) ? date('d-m-Y G:i:s', $time) : 'n/a';
}
// if(!in_array(PROPERTY_PROCESSINSTANCES_CURRENTACTIVITYEXECUTIONS, $excludedProperties)){
// $currentActivityExecutions = $processExecutionService->getCurrentActivityExecutions($processInstance);
// $this->data[$rowId][PROPERTY_PROCESSINSTANCES_CURRENTACTIVITYEXECUTIONS] = new wfAuthoring_helpers_Monitoring_ActivityMonitoringGrid(array_keys($currentActivityExecutions));
// }
if (isset($this->data[$rowId][$columnId])) {
$returnValue = $this->data[$rowId][$columnId];
}
}
}
return $returnValue;
}
public function run()
{
//set_time_limit(200);
helpers_TimeOutHelper::setTimeOutLimit(helpers_TimeOutHelper::LONG);
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
$processDefinitionUri = $this->getRequestParameter('processDefinition');
$processDefinition = new core_kernel_classes_Resource($processDefinitionUri);
if (!$this->hasRequestParameter('serviceCallId')) {
throw new common_exception_Error('No serviceCallId on service call');
}
$serviceService = tao_models_classes_service_StateStorage::singleton();
$userUri = common_session_SessionManager::getSession()->getUserUri();
$processExecutionUri = is_null($userUri) ? null : $serviceService->get($userUri, $this->getRequestParameter('serviceCallId'));
if (is_null($processExecutionUri)) {
$processExecName = $processDefinition->getLabel();
$processExecComment = 'Created in Processes server on ' . date(DATE_ISO8601);
if (isset($_REQUEST['processVariables']) && !empty($_REQUEST['processVariables'])) {
$processVariables = json_decode($_REQUEST['processVariables'], true);
$processVariables = is_array($processVariables) ? $processVariables : array();
} else {
// none provided
$processVariables = array();
}
$newProcessExecution = $processExecutionService->createProcessExecution($processDefinition, $processExecName, $processExecComment, $processVariables);
$processExecutionUri = $newProcessExecution->getUri();
$serviceService->set($userUri, $this->getRequestParameter('serviceCallId'), $processExecutionUri);
}
$processExecution = new core_kernel_classes_Resource($processExecutionUri);
//create nonce to initial activity executions:
foreach ($processExecutionService->getCurrentActivityExecutions($processExecution) as $initialActivityExecution) {
$activityExecutionService->createNonce($initialActivityExecution);
}
helpers_TimeOutHelper::reset();
$param = array('processUri' => urlencode($processExecution->getUri()), 'standalone' => 'true');
$this->redirect(tao_helpers_Uri::url('index', null, null, $param));
}
/**
* Test the sequential process execution:
*/
public function testVirtualSequencialProcess()
{
error_reporting(E_ALL);
try {
$t_start = microtime(true);
$authoringService = wfAuthoring_models_classes_ProcessService::singleton();
$activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
$activityExecutionService->cache = (bool) self::SERVICE_CACHE;
$this->service = wfEngine_models_classes_ProcessExecutionService::singleton();
//create a new process def
$processDefinition = $authoringService->createProcess('ProcessForUnitTest', 'Unit test');
$this->assertIsA($processDefinition, 'core_kernel_classes_Resource');
//define activities and connectors
$activity1 = $authoringService->createActivity($processDefinition, 'activity1');
$this->assertNotNull($activity1);
$authoringService->setFirstActivity($processDefinition, $activity1);
$connector1 = null;
$connector1 = $authoringService->createConnector($activity1);
$authoringService->setConnectorType($connector1, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector1);
$activity2 = $authoringService->createSequenceActivity($connector1, null, 'activity2');
$this->assertNotNull($activity2);
$connector2 = null;
$connector2 = $authoringService->createConnector($activity2);
$authoringService->setConnectorType($connector2, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector2);
$activity3 = $authoringService->createSequenceActivity($connector2, null, 'activity3');
$this->assertNotNull($activity3);
$connector3 = null;
$connector3 = $authoringService->createConnector($activity3);
$authoringService->setConnectorType($connector3, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector3);
$activity4 = $authoringService->createSequenceActivity($connector3, null, 'activity4');
$this->assertNotNull($activity4);
$connector4 = null;
$connector4 = $authoringService->createConnector($activity4);
$authoringService->setConnectorType($connector4, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector4);
$activity5 = $authoringService->createSequenceActivity($connector4, null, 'activity5');
$this->assertNotNull($activity5);
//run the process
$processExecName = 'Test Process Execution';
$processExecComment = 'created for processExecustionService test case by ' . __METHOD__;
$processInstance = $this->service->createProcessExecution($processDefinition, $processExecName, $processExecComment);
$this->assertEquals($processDefinition->getUri(), $this->service->getExecutionOf($processInstance)->getUri());
$this->assertEquals($processDefinition->getUri(), $this->service->getExecutionOf($processInstance)->getUri());
$this->assertTrue($this->service->checkStatus($processInstance, 'started'));
$this->out(__METHOD__, true);
$currentActivityExecutions = $this->service->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);
$previousActivityExecution = null;
//to test undoing the transitions
$iterationNumber = 5;
$i = 1;
while ($i <= $iterationNumber) {
if ($i < $iterationNumber) {
//try deleting a process that is not finished
$this->assertFalse($this->service->deleteProcessExecution($processInstance, true));
}
$activitieExecs = $this->service->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);
//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
$transitionResult = $this->service->performTransition($processInstance, $activityExecution);
//try undoing the transition:
switch ($i) {
case 2:
case 4:
$this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution));
$activitieExecs = $this->service->getCurrentActivityExecutions($processInstance);
$this->assertEquals(count($activitieExecs), 1);
$activity = $activityExecutionService->getExecutionOf(reset($activitieExecs));
$this->assertTrue($activity->getLabel() == 'activity' . $i);
$transitionResult = $this->service->performTransition($processInstance, $activityExecution);
break;
case 3:
$history = $this->service->getExecutionHistory($processInstance);
$this->assertEquals(count($history), 5);
//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;
}
if ($i < $iterationNumber) {
$this->assertTrue(count($transitionResult) > 0);
} else {
$this->assertFalse(count($transitionResult) > 0);
}
$this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel());
$this->out("process status: " . $this->service->getStatus($processInstance)->getLabel());
$this->assertFalse($this->service->isPaused($processInstance));
$previousActivityExecution = $activityExecution;
$i++;
}
$this->assertTrue($this->service->isFinished($processInstance));
$this->assertTrue($this->service->resume($processInstance));
$this->out("<strong>Backward transitions:</strong>", true);
$j = 0;
while ($j < $iterationNumber) {
$activitieExecs = $this->service->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}");
//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);
//transition to next activity
$transitionResult = $this->service->performBackwardTransition($processInstance, $activityExecution);
$processStatus = $this->service->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: " . $this->service->getStatus($processInstance)->getLabel());
$j++;
}
$this->out("<strong>Forward transitions again:</strong>", true);
$previousActivityExecution = null;
$i = 1;
while ($i <= $iterationNumber) {
if ($i < $iterationNumber) {
//try deleting a process that is not finished
$this->assertFalse($this->service->deleteProcessExecution($processInstance, true));
}
$activitieExecs = $this->service->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);
//init execution
$activityExecution = $this->service->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser);
$this->assertNotNull($activityExecution);
$activityExecStatus = $activityExecutionService->getStatus($activityExecution);
$this->assertNotNull($activityExecStatus);
if ($i == 1) {
$this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED);
} else {
$this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_STARTED);
}
//transition to next activity
$transitionResult = $this->service->performTransition($processInstance, $activityExecution);
//try undoing the transition:
switch ($i) {
case 2:
case 3:
$this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution));
$activitieExecs = $this->service->getCurrentActivityExecutions($processInstance);
$this->assertEquals(count($activitieExecs), 1);
$activity = $activityExecutionService->getExecutionOf(reset($activitieExecs));
$this->assertTrue($activity->getLabel() == 'activity' . $i);
$transitionResult = $this->service->performTransition($processInstance, $activityExecution);
break;
case 3:
case 4:
$history = $this->service->getExecutionHistory($processInstance);
$this->assertFalse($this->service->undoForwardTransition($processInstance, new core_kernel_classes_Resource(reset($history))));
$this->assertNotNull($previousActivityExecution);
$this->assertFalse($this->service->undoForwardTransition($processInstance, $previousActivityExecution));
break;
}
if ($i < $iterationNumber) {
$this->assertTrue(count($transitionResult) > 0);
} else {
$this->assertFalse(count($transitionResult) > 0);
}
$this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel());
$this->out("process status: " . $this->service->getStatus($processInstance)->getLabel());
$this->assertFalse($this->service->isPaused($processInstance));
$previousActivityExecution = $activityExecution;
$i++;
}
$this->assertTrue($this->service->isFinished($processInstance));
$t_end = microtime(true);
$duration = $t_end - $t_start;
$this->out('Elapsed time: ' . $duration . 's', true);
//delete processdef:
$this->assertTrue($authoringService->deleteProcess($processDefinition));
//delete process execution:
$this->assertTrue($processInstance->exists());
$this->assertTrue($this->service->deleteProcessExecution($processInstance));
$this->assertFalse($processInstance->exists());
if (!is_null($this->currentUser)) {
$this->userService->logout();
$this->userService->removeUser($this->currentUser);
}
} catch (common_Exception $ce) {
$this->fail($ce);
}
}
/**
* Test the notifications in a sequencial process
*/
public function testNotificationsInProcess()
{
try {
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$authoringService = wfAuthoring_models_classes_ProcessService::singleton();
$activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
$roleService = wfEngine_models_classes_RoleService::singleton();
//create a new process def
$processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS);
$processDefinition = $processDefinitionClass->createInstance('ProcessForUnitTest', 'Unit test');
$this->assertIsA($processDefinition, 'core_kernel_classes_Resource');
$aclModeRole = new core_kernel_classes_Resource(INSTANCE_ACL_ROLE);
$aclModeUser = new core_kernel_classes_Resource(INSTANCE_ACL_USER);
$wfRole = new core_kernel_classes_Resource(INSTANCE_ROLE_WORKFLOW);
$role1 = $roleService->addRole('Role 1', $wfRole);
$role2 = $roleService->addRole('Role 2', $wfRole);
$roleService->setRoleToUsers($role2, array($this->currentUser));
//define activities and connectors
$activity1 = $authoringService->createActivity($processDefinition, 'activity1');
$this->assertNotNull($activity1);
$authoringService->setFirstActivity($processDefinition, $activity1);
//activity is allowed to the created role
$activityExecutionService->setAcl($activity1, $aclModeRole, $role2);
$connector1 = null;
$connector1 = $authoringService->createConnector($activity1);
$authoringService->setConnectorType($connector1, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector1);
$this->service->bindProperties($connector1, array(PROPERTY_CONNECTORS_NOTIFY => INSTANCE_NOTIFY_USER, PROPERTY_CONNECTORS_USER_NOTIFIED => $this->currentUser->getUri(), PROPERTY_CONNECTORS_NOTIFICATION_MESSAGE => 'Connector 1 notification to user ' . $this->currentUser->getLabel()));
$activity2 = $authoringService->createSequenceActivity($connector1, null, 'activity2');
$this->assertNotNull($activity2);
//2nd activity is allowed to create role
$activityExecutionService->setAcl($activity2, $aclModeRole, $role2);
$connector2 = null;
$connector2 = $authoringService->createConnector($activity2);
$authoringService->setConnectorType($connector2, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector2);
$this->service->bindProperties($connector2, array(PROPERTY_CONNECTORS_NOTIFY => INSTANCE_NOTIFY_PREVIOUS, PROPERTY_CONNECTORS_NOTIFICATION_MESSAGE => 'Connector 2 notification to previous activity user ' . $this->currentUser->getLabel()));
$activity3 = $authoringService->createSequenceActivity($connector2, null, 'activity3');
$this->assertNotNull($activity3);
$connector3 = null;
$connector3 = $authoringService->createConnector($activity3);
$authoringService->setConnectorType($connector3, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector3);
$this->service->bindProperties($connector3, array(PROPERTY_CONNECTORS_NOTIFY => INSTANCE_NOTIFY_NEXT, PROPERTY_CONNECTORS_NOTIFICATION_MESSAGE => 'Connector 3 notification to next activity user ' . $this->currentUser->getLabel()));
$activity4 = $authoringService->createSequenceActivity($connector3, null, 'activity4');
$this->assertNotNull($activity4);
//allowed to the currentUser only
$activityExecutionService->setAcl($activity4, $aclModeUser, $this->currentUser);
$connector4 = null;
$connector4 = $authoringService->createConnector($activity4);
$authoringService->setConnectorType($connector4, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE));
$this->assertNotNull($connector4);
$this->service->bindProperties($connector4, array(PROPERTY_CONNECTORS_NOTIFY => INSTANCE_NOTIFY_ROLE, PROPERTY_CONNECTORS_ROLE_NOTIFIED => $role2->getUri(), PROPERTY_CONNECTORS_NOTIFICATION_MESSAGE => 'Connector 4 notification to role user ' . $role2->getLabel()));
$activity5 = $authoringService->createSequenceActivity($connector4, null, 'activity5');
$this->assertNotNull($activity5);
//run the process
$processExecName = 'Test Process Execution';
$processExecComment = 'created for Notification service test case by ' . __METHOD__;
$proc = $processExecutionService->createProcessExecution($processDefinition, $processExecName, $processExecComment);
$i = 1;
while ($i <= 5) {
$activityExecs = $processExecutionService->getAvailableCurrentActivityExecutions($proc, $this->currentUser);
$this->assertEquals(count($activityExecs), 1);
$activityExec = reset($activityExecs);
$activity = $activityExecutionService->getExecutionOf($activityExec);
$this->out("<strong>" . $activity->getLabel() . "</strong>", true);
$this->assertTrue($activity->getLabel() == 'activity' . $i);
//init execution
$activityExecution = $processExecutionService->initCurrentActivityExecution($proc, $activityExec, $this->currentUser);
$this->assertIsA($activityExecution, "core_kernel_classes_Resource");
//transition to nextactivity
$transitionResult = $processExecutionService->performTransition($proc, $activityExecution);
$this->assertFalse($processExecutionService->isPaused($proc));
$i++;
}
$this->assertTrue($processExecutionService->isFinished($proc));
//check the created notifications
$notifications = array();
$notificationProcessExecProp = new core_kernel_classes_Property(PROPERTY_NOTIFICATION_PROCESS_EXECUTION);
$notificationToProp = new core_kernel_classes_Property(PROPERTY_NOTIFICATION_TO);
$notificationsToSend = $this->service->getNotificationsToSend();
$this->assertTrue(count($notificationsToSend) > 0);
foreach ($this->service->getNotificationsToSend() as $notification) {
$notificationProcess = $notification->getOnePropertyValue($notificationProcessExecProp);
if (!is_null($notificationProcess)) {
if ($notificationProcess->getUri() == $proc->getUri()) {
$notifiedUser = $notification->getOnePropertyValue($notificationToProp);
$this->assertNotNull($notifiedUser);
$this->assertEquals($notifiedUser->getUri(), $this->currentUser->getUri());
$notifications[] = $notification;
}
}
}
$notificationCount = count($notifications);
$this->assertEquals($notificationCount, 4);
// $this->out("$notificationCount notifications to be sent");
// $this->assertTrue($this->service->sendNotifications(new tao_helpers_transfert_MailAdapter()));
// $this->out("All notifications sent");
//delete notifications:
foreach ($notifications as $notification) {
$this->assertTrue($notification->delete());
}
$this->assertTrue($role2->delete());
//delete process exec:
$this->assertTrue($processExecutionService->deleteProcessExecution($proc));
//delete processdef:
$this->assertTrue($authoringService->deleteProcess($processDefinition));
if (!is_null($this->currentUser)) {
$this->userService->logout();
$this->assertTrue($this->userService->removeUser($this->currentUser));
}
} catch (common_Exception $ce) {
$this->fail($ce);
}
}
/**
*
* 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');
}
public function testDeleteCreatedResources()
{
if (isset($this->config['delete']) && $this->config['delete'] === false) {
$this->out('Skip resources deletion');
return;
}
if (!empty($this->properties)) {
foreach ($this->properties as $prop) {
$this->assertTrue($prop->delete());
}
}
if (!is_null($this->itemClass)) {
$this->itemClass->delete();
}
if (!empty($this->units)) {
foreach ($this->units as $unit) {
$this->assertTrue($unit->delete());
}
}
if (!empty($this->files)) {
foreach ($this->files as $file) {
$this->assertTrue($file->delete());
}
}
if (!empty($this->users)) {
foreach ($this->users as $user) {
$this->assertTrue($user->delete());
}
}
if (!empty($this->roles)) {
foreach ($this->roles as $role) {
$this->assertTrue($role->delete());
}
}
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
foreach ($this->processExecutions as $processInstance) {
if ($processInstance instanceof core_kernel_classes_Resource) {
$this->assertTrue($processInstance->exists());
$this->assertTrue($processExecutionService->deleteProcessExecution($processInstance));
$this->assertFalse($processInstance->exists());
}
}
foreach ($this->processDefinition as $process) {
if ($process instanceof core_kernel_classes_Resource) {
$authoringService = wfAuthoring_models_classes_ProcessService::singleton();
$this->assertTrue($authoringService->deleteProcess($process));
$this->assertFalse($process->exists());
}
}
if (!empty($this->vars)) {
foreach ($this->vars as $code => $variable) {
$deleted = $variable->delete();
$this->assertTrue($deleted);
if (!$deleted) {
var_dump($code);
}
}
}
}
/**
* Short description of method moveBackward
*
* @access public
* @author Somsack Sipasseuth, <*****@*****.**>
* @param Resource activityExecution
* @param Resource processExecution
* @param array revertOptions
* @return array
*/
public function moveBackward(core_kernel_classes_Resource $activityExecution, core_kernel_classes_Resource $processExecution, $revertOptions = array())
{
$returnValue = array();
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
//fill options:
$revert = isset($revertOptions['revert']) ? (bool) $revertOptions['revert'] : true;
$newVariables = isset($revertOptions['newVariables']) && is_array($revertOptions['newVariables']) ? $revertOptions['newVariables'] : array();
$notResumed = isset($revertOptions['notResumed']) && is_array($revertOptions['notResumeds']) ? $revertOptions['notResumed'] : array();
//check if the previous connector is not parallel:
$previousActivityExecutions = array();
$previous = $activityExecution->getPropertyValues($this->activityExecutionPreviousProperty);
$count = count($previous);
for ($i = 0; $i < $count; $i++) {
if (common_Utils::isUri($previous[$i])) {
$prevousActivityExecution = new core_kernel_classes_Resource($previous[$i]);
if (count($prevousActivityExecution->getPropertyValues($this->activityExecutionFollowingProperty)) == 1) {
$previousActivityExecutions[$prevousActivityExecution->getUri()] = $prevousActivityExecution;
} else {
return false;
//forbidden to go backward of a parallel connector
}
}
}
if (!empty($previousActivityExecutions)) {
//set the process' current activity executions:
$processExecutionService->removeCurrentActivityExecutions($processExecution, array($activityExecution));
//not performance efficient:
// $activityExecution->delete();
// $processExecution->removePropertyValues(
// new core_kernel_classes_Property(PROPERTY_PROCESSINSTANCES_ACTIVITYEXECUTIONS),
// array(
// 'like' => false,
// 'pattern' => array()
// ));
//instead, set the current activity execution as closed (i.e. invalidate the path):
$this->setStatus($activityExecution, 'closed');
foreach ($previousActivityExecutions as $previousActivityExecution) {
$previousActivityExecution->removePropertyValues($this->activityExecutionFollowingProperty);
//manage the additional option to full revert (default behaviour), full merge or partial merge (i.e. redifine some process variable values)
if (!$revert) {
$overwritingVariables = array();
if (isset($newVariables[$previousActivityExecution->getUri()])) {
$overwritingVariables = $newVariables[$previousActivityExecution->getUri()];
}
$this->mergeActivityExecutionVariables($previousActivityExecution, array($activityExecution), $processExecution, $overwritingVariables);
}
//change the status of the activity executions to 'paused' by default or nothing if not required (parallel branch):
if (!isset($notResumed[$previousActivityExecution->getUri()])) {
$this->setStatus($previousActivityExecution, 'paused');
}
}
if ($processExecutionService->setCurrentActivityExecutions($processExecution, $previousActivityExecutions)) {
$returnValue = $previousActivityExecutions;
}
}
return (array) $returnValue;
}
private function runProcess($processDefinition, $expectedSteps)
{
$user = $this->createUser('timmy');
$this->changeUser('timmy');
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
$processInstance = $processExecutionService->createProcessExecution($processDefinition, $processDefinition->getLabel() . ' instance', '');
$currentActivityExecutions = $processExecutionService->getCurrentActivityExecutions($processInstance);
$steps = 0;
while (count($currentActivityExecutions) > 0) {
$steps++;
$current = array_shift($currentActivityExecutions);
$transitionResult = $processExecutionService->performTransition($processInstance, $current);
if ($transitionResult !== false) {
foreach ($transitionResult as $executed) {
$this->assertTrue($executed->hasType(new core_kernel_classes_Class(CLASS_ACTIVITY_EXECUTION)));
}
}
$currentActivityExecutions = $processExecutionService->getCurrentActivityExecutions($processInstance);
foreach ($currentActivityExecutions as $key => $exec) {
$status = wfEngine_models_classes_ActivityExecutionService::singleton()->getStatus($exec);
if (!is_null($status) && $status->getUri() == INSTANCE_PROCESSSTATUS_FINISHED) {
unset($currentActivityExecutions[$key]);
}
}
}
$this->assertEquals($steps, $expectedSteps);
$processExecutionService->deleteProcessExecution($processInstance);
$user->delete();
$this->logoutUser();
}
/**
* 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);
}
}
/**
* Short description of method trigger
*
* @access public
* @author Somsack Sipasseuth, <*****@*****.**>
* @param Resource connector
* @param Resource activityExecution
* @param Resource processExecution
* @return int
*/
public function trigger(core_kernel_classes_Resource $connector, core_kernel_classes_Resource $activityExecution, core_kernel_classes_Resource $processExecution = null)
{
$returnValue = (int) 0;
if (!is_null($connector) && !is_null($activityExecution)) {
//initialize properties
$connectorUserNotifiedProp = new core_kernel_classes_Property(PROPERTY_CONNECTORS_USER_NOTIFIED);
$connectorRoleNotifiedProp = new core_kernel_classes_Property(PROPERTY_CONNECTORS_ROLE_NOTIFIED);
$connectorNextActivitiesProp = new core_kernel_classes_Property(PROPERTY_STEP_NEXT);
$activityExecutionUserProp = new core_kernel_classes_Property(PROPERTY_ACTIVITY_EXECUTION_CURRENT_USER);
$activityAclModeProp = new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ACL_MODE);
$activityAclUserProp = new core_kernel_classes_Property(PROPERTY_ACTIVITIES_RESTRICTED_USER);
$activityAclRoleProp = new core_kernel_classes_Property(PROPERTY_ACTIVITIES_RESTRICTED_ROLE);
$connectorService = wfEngine_models_classes_ConnectorService::singleton();
$transitionRuleService = wfEngine_models_classes_TransitionRuleService::singleton();
$roleService = wfEngine_models_classes_RoleService::singleton();
$activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton();
$processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton();
if (is_null($processExecution)) {
$processExecution = $activityExecutionService->getRelatedProcessExecution($activityExecution);
}
$users = array();
//get the notifications mode defined for that connector
$notifyModes = $connector->getPropertyValuesCollection(new core_kernel_classes_Property(PROPERTY_CONNECTORS_NOTIFY));
foreach ($notifyModes->getIterator() as $notify) {
$nextActivities = array();
//get the users regarding the notification mode
switch ($notify->getUri()) {
//users directly defined
case INSTANCE_NOTIFY_USER:
foreach ($connector->getPropertyValues($connectorUserNotifiedProp) as $userUri) {
if (!in_array($userUri, $users)) {
$users[] = $userUri;
}
}
break;
//users from roles directly defined
//users from roles directly defined
case INSTANCE_NOTIFY_ROLE:
foreach ($connector->getPropertyValues($connectorRoleNotifiedProp) as $roleUri) {
foreach ($roleService->getUsers(new core_kernel_classes_Resource($roleUri)) as $userUri) {
if (!in_array($userUri, $users)) {
$users[] = $userUri;
}
}
}
break;
//get the users who have executed the previous activity
//get the users who have executed the previous activity
case INSTANCE_NOTIFY_PREVIOUS:
$previousActivities = array();
$cardinalityService = wfEngine_models_classes_ActivityCardinalityService::singleton();
foreach ($connectorService->getPreviousActivities($connector) as $prevActivity) {
if ($cardinalityService->isCardinality($prevActivity)) {
$previousActivities[] = $cardinalityService->getSource($prevActivity)->getUri();
} else {
$previousActivities[] = $prevActivity->getUri();
}
}
$activity = $activityExecutionService->getExecutionOf($activityExecution);
//check activity execution against connector
if (in_array($activity->getUri(), $previousActivities)) {
$activityExecutionUser = $activityExecutionService->getActivityExecutionUser($activityExecution);
if (!is_null($activityExecutionUser)) {
if (!in_array($activityExecutionUser->getUri(), $users)) {
$users[] = $activityExecutionUser->getUri();
}
}
}
break;
//get the users
//get the users
case INSTANCE_NOTIFY_THEN:
if ($connectorService->getType($connector)->getUri() == INSTANCE_TYPEOFCONNECTORS_CONDITIONAL) {
$transitionRule = $connectorService->getTransitionRule($connector);
if ($transitionRule instanceof core_kernel_classes_Resource) {
$then = $transitionRuleService->getThenActivity($transitionRule);
if ($then instanceof core_kernel_classes_Resource) {
$nextActivities[] = $then->getUri();
}
}
} else {
//wrong connector type!
break;
}
//do not break, continue to the INSTANCE_NOTIFY_NEXT case
case INSTANCE_NOTIFY_ELSE:
if (empty($nextActivities)) {
if ($connectorService->getType($connector)->getUri() == INSTANCE_TYPEOFCONNECTORS_CONDITIONAL) {
$transitionRule = $connectorService->getTransitionRule($connector);
if ($transitionRule instanceof core_kernel_classes_Resource) {
$else = $transitionRuleService->getElseActivity($transitionRule);
if ($else instanceof core_kernel_classes_Resource) {
$nextActivities[] = $else->getUri();
}
}
} else {
//wrong connector type!
break;
}
}
//do not break, continue to the INSTANCE_NOTIFY_NEXT case
case INSTANCE_NOTIFY_NEXT:
if (empty($nextActivities)) {
$cardinalityService = wfEngine_models_classes_ActivityCardinalityService::singleton();
foreach ($connectorService->getNextActivities($connector) as $nextActivity) {
if ($cardinalityService->isCardinality($nextActivity)) {
$nextActivities[] = $cardinalityService->getDestination($nextActivity)->getUri();
} else {
$nextActivities[] = $nextActivity->getUri();
}
}
}
$nextActivityExecutions = $activityExecutionService->getFollowing($activityExecution);
foreach ($nextActivityExecutions as $activityExec) {
$activity = $activityExecutionService->getExecutionOf($activityExec);
if (!in_array($activity->getUri(), $nextActivities)) {
//invalid activity exec
continue;
}
//check if it is among the next activity of the connector:
$mode = $activityExecutionService->getAclMode($activityExec);
if ($mode instanceof core_kernel_classes_Resource) {
switch ($mode->getUri()) {
case INSTANCE_ACL_USER:
$restrictedUser = $activityExecutionService->getRestrictedUser($activityExec);
//@TODO: implemente multiple restricted users?
if (!is_null($restrictedUser)) {
if (!in_array($restrictedUser->getUri(), $users)) {
$users[] = $restrictedUser->getUri();
}
}
break;
case INSTANCE_ACL_ROLE:
case INSTANCE_ACL_ROLE_RESTRICTED_USER:
case INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED:
$restrictedRole = $activityExecutionService->getRestrictedRole($activityExec);
//@TODO: implemente multiple restricted roles?
if (!is_null($restrictedRole)) {
foreach ($roleService->getUsers($restrictedRole) as $userUri) {
if (!in_array($userUri, $users)) {
$users[] = $userUri;
}
}
}
break;
}
}
}
break;
}
}
//build notification message for every user here:
foreach ($users as $userUri) {
if ($this->createNotification($connector, new core_kernel_classes_Resource($userUri), $activityExecution, $processExecution)) {
//get message from connector:
//replace SPX in message bodies
$returnValue++;
}
}
}
return (int) $returnValue;
}