/**
* 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);
}
}
/**
* 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);
}
}
/**
* Test generation of users:
*/
public function testCreateUsers()
{
error_reporting(E_ALL);
if ($this->createUsers) {
$roleService = wfEngine_models_classes_RoleService::singleton();
$usec = time();
$this->userLogins = array();
$this->users = array();
//create roles and users:
$roleService = tao_models_classes_RoleService::singleton();
$wfRole = new core_kernel_classes_Resource(INSTANCE_ROLE_WORKFLOW);
$this->roles = array();
$this->roles['consortium'] = $roleService->addRole('consortium - ' . $usec, $wfRole);
$this->roles['NPM'] = $roleService->addRole('NPMs - ' . $usec, $wfRole);
$this->roles['translator'] = $roleService->addRole('translators - ' . $usec, $wfRole);
$this->roles['reconciler'] = $roleService->addRole('reconcilers - ' . $usec, $wfRole);
$this->roles['verifier'] = $roleService->addRole('verifiers - ' . $usec, $wfRole);
$this->roles['developer'] = $roleService->addRole('developers - ' . $usec, $wfRole);
$this->roles['testDeveloper'] = $roleService->addRole('test developers - ' . $usec, $wfRole);
$classRole = new core_kernel_classes_Class(CLASS_ROLE);
$translatorClass = $classRole->createSubClass('translatorsTestClass');
foreach ($this->roles as $role) {
$role->setType($translatorClass);
$role->removeType($classRole);
}
//create the country code and language code properties to the wf user class:
$propUserCountryCode = $this->createTranslationProperty('CountryCode', '', '', $translatorClass);
$propUserLangCode = $this->createTranslationProperty('LanguageCode', '', '', $translatorClass);
//generate users' logins:
$this->userLogins = array();
$this->roleLogins = array();
$this->userLogins['consortium'] = array();
$memberConsortium = 1;
for ($i = 1; $i <= $memberConsortium; $i++) {
$this->userLogins['consortium'][$i] = 'consortium_' . $i . '_' . $usec;
//the process admin
$this->roleLogins[$this->roles['consortium']->getUri()][] = $this->userLogins['consortium'][$i];
}
$this->userLogins['developer'] = array();
$nbDevelopers = 6;
for ($i = 1; $i <= $nbDevelopers; $i++) {
$this->userLogins['developer'][$i] = 'developer_' . $i . '_' . $usec;
//ETS_01, ETS_02, etc.
$this->roleLogins[$this->roles['developer']->getUri()][] = $this->userLogins['developer'][$i];
}
$this->userLogins['testDeveloper'] = array();
$nbTestDevelopers = 3;
for ($i = 1; $i <= $nbTestDevelopers; $i++) {
$this->userLogins['testDeveloper'][$i] = 'testDeveloper_' . $i . '_' . $usec;
//test creators
$this->roleLogins[$this->roles['testDeveloper']->getUri()][] = $this->userLogins['testDeveloper'][$i];
}
$nbTranslatorsByCountryLang = 3;
foreach ($this->langCountries as $countryCode => $languageCodes) {
$this->userLogins[$countryCode] = array();
//one NPM by country
$this->userLogins[$countryCode]['NPM'] = 'NPM_' . $countryCode . '_' . $usec;
$this->roleLogins[$this->roles['NPM']->getUri()][] = $this->userLogins[$countryCode]['NPM'];
foreach ($languageCodes as $languageCode) {
//one reconciler and verifier by country-language
$this->userLogins[$countryCode][$languageCode] = array('translator' => array(), 'reconciler' => 'reconciler_' . $countryCode . '_' . $languageCode . '_' . $usec, 'verifier' => 'verifier_' . $countryCode . '_' . $languageCode . '_' . $usec);
$this->roleLogins[$this->roles['reconciler']->getUri()][] = $this->userLogins[$countryCode][$languageCode]['reconciler'];
$this->roleLogins[$this->roles['verifier']->getUri()][] = $this->userLogins[$countryCode][$languageCode]['verifier'];
//as many translators as wanted:
for ($i = 1; $i <= $nbTranslatorsByCountryLang; $i++) {
$this->userLogins[$countryCode][$languageCode]['translator'][$i] = 'translator_' . $countryCode . '_' . $languageCode . '_' . $i . '_' . $usec;
$this->roleLogins[$this->roles['translator']->getUri()][] = $this->userLogins[$countryCode][$languageCode]['translator'][$i];
}
}
}
$this->createUsers($this->userLogins);
foreach ($this->roleLogins as $roleUri => $usrs) {
$role = new core_kernel_classes_Resource($roleUri);
$userUris = array();
foreach ($usrs as $login) {
if (isset($this->users[$login])) {
$matchesarray = array();
if (preg_match_all('/translator_(.[^_]*)_(.[^_]*)_/', $login, $matchesarray) > 0) {
$countryCode = $matchesarray[1][0];
$langCode = $matchesarray[2][0];
$this->assertTrue($this->users[$login]->setPropertyValue($propUserCountryCode, $countryCode));
$this->assertTrue($this->users[$login]->setPropertyValue($propUserLangCode, $langCode));
}
$userUris[] = $this->users[$login]->getUri();
}
}
$this->assertTrue($roleService->setRoleToUsers($role, $userUris));
}
}
}
/**
* 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;
}
