/** * 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; }