public function testVirtualProcess() { $processAuthoringService = wfAuthoring_models_classes_ProcessService::singleton(); $processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS); $processDefinition = $processDefinitionClass->createInstance('ProcessForUnitTest', 'Unit test'); $this->assertIsA($processDefinition, 'core_kernel_classes_Resource'); $authoringService = wfAuthoring_models_classes_ProcessService::singleton(); //define activities and connectors $activity1 = $authoringService->createActivity($processDefinition, 'activity1'); $this->assertNotNull($activity1); $authoringService->setFirstActivity($processDefinition, $activity1); //check first activity $this->assertTrue($this->service->isActivity($activity1)); $this->assertTrue($this->service->isInitial($activity1)); $connector1 = $authoringService->createConnector($activity1); $authoringService->setConnectorType($connector1, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE)); $activity2 = $authoringService->createSequenceActivity($connector1, null, 'activity2'); $this->assertNotNull($activity2); $this->assertTrue($this->service->isActivity($activity2)); $this->assertFalse($this->service->isFinal($activity1)); $this->assertFalse($this->service->isInitial($activity2)); $this->assertTrue($this->service->isFinal($activity2)); $activity1->delete(true); $connector1->delete(true); $activity2->delete(true); $processDefinition->delete(true); }
public function testCheckProcess() { $id = '_unit_pr_check_'; $processChecker = new wfAuthoring_models_classes_ProcessChecker($this->proc); $activity1 = $this->authoringService->createActivity($this->proc, "{$id}Activity_1"); $activity1->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISINITIAL), GENERIS_TRUE); $connector1 = $this->authoringService->createConnector($activity1); $then1 = $this->authoringService->createConditionalActivity($connector1, 'then', null, "{$id}Activity_2"); //create "Activity_2" $else1 = $this->authoringService->createConditionalActivity($connector1, 'else', null, '', true); //create another connector $this->assertEquals($connector1->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_TYPE))->getUri(), INSTANCE_TYPEOFCONNECTORS_CONDITIONAL); $activityService = wfEngine_models_classes_ActivityService::singleton(); $this->assertTrue($activityService->isActivity($then1)); $connectorService = wfEngine_models_classes_ConnectorService::singleton(); $this->assertTrue($connectorService->isConnector($else1)); $transitionRule = $connector1->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_TRANSITIONRULE)); $this->assertEquals($then1->getUri(), $transitionRule->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_TRANSITIONRULES_THEN))->getUri()); $this->assertEquals($else1->getUri(), $transitionRule->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_TRANSITIONRULES_ELSE))->getUri()); //create a sequential a $connector2 = $this->authoringService->createConnector($then1); $lastActivity = $this->authoringService->createSequenceActivity($connector2, null, "{$id}Activity_3"); //connector "else1": connect the "then" to the activity "then1" and the "else" to $then2 = $this->authoringService->createConditionalActivity($else1, 'then', $connector2); //connect to the activity $then1 $else2 = $this->authoringService->createConditionalActivity($else1, 'else', $lastActivity); //connect to the connector of the activity $then1 $this->assertEquals($then2->getUri(), $connector2->getUri()); $this->assertEquals($else2->getUri(), $lastActivity->getUri()); $this->assertTrue($processChecker->check()); }
/** * Walk through the cloned process and replace the item runner placeholders * * @param core_kernel_classes_Resource $processDefinition */ protected function process(core_kernel_classes_Resource $processDefinition) { $report = new common_report_Report(common_report_Report::TYPE_SUCCESS); $activities = wfEngine_models_classes_ProcessDefinitionService::singleton()->getAllActivities($processDefinition); foreach ($activities as $activity) { $services = wfEngine_models_classes_ActivityService::singleton()->getInteractiveServices($activity); foreach ($services as $service) { $serviceDefinition = $service->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CALLOFSERVICES_SERVICEDEFINITION)); if ($serviceDefinition->getUri() == INSTANCE_ITEMCONTAINER_SERVICE) { $item = taoWfTest_models_classes_WfTestService::singleton()->getItemByService($service); if (is_null($item)) { $report->add($this->fail(__('No valid item found for service "%s"', $service->getLabel()))); } else { $itemReport = $this->subCompile($item); if ($itemReport->getType() == common_report_Report::TYPE_SUCCESS) { $serviceCall = $itemReport->getData(); $storedServiceCall = $serviceCall->toOntology(); // remove old service wfEngine_models_classes_InteractiveServiceService::singleton()->deleteInteractiveService($service); $activity->removePropertyValue(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_INTERACTIVESERVICES), $service); // add new service $activity->setPropertyValue(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_INTERACTIVESERVICES), $storedServiceCall); } $report->add($itemReport); if ($itemReport->getType() != common_report_Report::TYPE_SUCCESS) { $report->setType($itemReport->getType()); } } } } } return $report; }
private function replaceItemRunner(core_kernel_classes_Resource $workflow, $directory) { $authoringService = wfAuthoring_models_classes_ProcessService::singleton(); // foreach activity in workflow foreach (wfEngine_models_classes_ProcessDefinitionService::singleton()->getAllActivities($workflow) as $activity) { foreach (wfEngine_models_classes_ActivityService::singleton()->getInteractiveServices($activity) as $service) { $serviceDefinition = $service->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CALLOFSERVICES_SERVICEDEFINITION)); if ($serviceDefinition->getUri() == self::OLD_ITEMRUNNER_SERVICE) { $this->out('to replace: ' . $service->getLabel()); // retrieve item $item = $this->getItem($service); // create service $itemDirectory = $this->createNamedSubDirectory($directory, $activity); $newService = $this->compileItem($item, $itemDirectory); $newService->setLabel($service->getLabel()); $activity->removePropertyValue(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_INTERACTIVESERVICES), $service); //delete its related properties $deleted = $authoringService->deleteActualParameters($service); //delete call of service itself $deleted = $service->delete(true); $activity->setPropertyValue(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_INTERACTIVESERVICES), $newService); } } $this->out('done activity: ' . $activity->getLabel()); } }
/** * Builds a simple Diagram of the Process * * @access public * @author Joel Bout, <*****@*****.**> * @param Resource process * @return string */ public static function buildDiagramData(core_kernel_classes_Resource $process) { $returnValue = (string) ''; common_Logger::i("Building diagram for " . $process->getLabel()); $authoringService = wfAuthoring_models_classes_ProcessService::singleton(); $activityService = wfEngine_models_classes_ActivityService::singleton(); $connectorService = wfEngine_models_classes_ConnectorService::singleton(); $activityCardinalityService = wfEngine_models_classes_ActivityCardinalityService::singleton(); $activities = $authoringService->getActivitiesByProcess($process); $todo = array(); foreach ($activities as $activity) { if ($activityService->isInitial($activity)) { $todo[] = $activity; } } $currentLevel = 0; $diagram = new wfAuthoring_models_classes_ProcessDiagram(); $done = array(); while (!empty($todo)) { $nextLevel = array(); $posOnLevel = 0; foreach ($todo as $item) { $next = array(); if ($activityService->isActivity($item)) { // add this activity $diagram->addActivity($item, 54 + 200 * $posOnLevel + 10 * $currentLevel, 35 + 80 * $currentLevel); $next = array_merge($next, $activityService->getNextConnectors($item)); common_Logger::d('Activity added ' . $item->getUri()); } elseif ($connectorService->isConnector($item)) { // add this connector $diagram->addConnector($item, 100 + 200 * $posOnLevel + 10 * $currentLevel, 40 + 80 * $currentLevel); $next = array_merge($next, $connectorService->getNextActivities($item)); } else { common_Logger::w('unexpected ressource in process ' . $item->getUri()); } //replace cardinalities foreach ($next as $key => $destination) { if ($activityCardinalityService->isCardinality($destination)) { // not represented on diagram $next[$key] = $activityCardinalityService->getDestination($destination); } } //add arrows foreach ($next as $destination) { $diagram->addArrow($item, $destination); } $posOnLevel++; $nextLevel = array_merge($nextLevel, $next); } $done = array_merge($done, $todo); $todo = array_diff($nextLevel, $done); $currentLevel++; } $returnValue = $diagram->toJSON(); return (string) $returnValue; }
public function __construct() { //init services $this->activityService = wfEngine_models_classes_ActivityService::singleton(); $this->processVariableService = wfEngine_models_classes_VariableService::singleton(); $this->authoringService = wfAuthoring_models_classes_ProcessService::singleton(); $this->activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton(); $this->connectorService = wfEngine_models_classes_ConnectorService::singleton(); $this->processVariablesClass = new core_kernel_classes_Class(CLASS_PROCESSVARIABLES); $this->propertyIsSample = new core_kernel_classes_Property(PROPERTY_IS_SAMPLE); }
protected function flattenProcessActivity(core_kernel_classes_Resource $activity) { $this->initCloningVariables(); $services = wfEngine_models_classes_ActivityService::singleton()->getInteractiveServices($activity); // only replace single-service activities, with the service process runner if (count($services) == 1) { $serviceCall = current($services); $serviceDefinition = $serviceCall->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CALLOFSERVICES_SERVICEDEFINITION)); if ($serviceDefinition->getUri() == INSTANCE_SERVICE_PROCESSRUNNER) { // found a wfEngine call, extract processDefnition $subProcess = $this->getSubProcess($serviceCall); if (empty($subProcess)) { throw new common_exception_InconsistentData('Missing process uri in service call ' . $serviceCall->getUri()); } // @todo test the process first // @todo clone sub process common_Logger::w('Should have cloned subprocess ' . $subProcess); $segment = $this->cloneProcessSegment($subProcess); $inActivity = $segment['in']; $firstout = current($segment['out']); //allow first acitvity only if the parent is if (!wfAuthoring_models_classes_ActivityService::singleton()->isInitial($activity)) { $inActivity->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISINITIAL), GENERIS_FALSE); } $this->addClonedActivity($inActivity, $activity, $firstout); $propProcessActivities = new core_kernel_classes_Property(PROPERTY_PROCESS_ACTIVITIES); foreach ($this->getClonedActivities() as $activityClone) { $this->processDefinition->setPropertyValue($propProcessActivities, $activityClone->getUri()); } //get the previous connector if exists and clone it $allConnectors = wfAuthoring_models_classes_ProcessService::singleton()->getConnectorsByActivity($activity); $connectors = array_merge($allConnectors['next'], $allConnectors['prev']); foreach ($connectors as $connector) { //trick to reference previous and following connector: connector_prev -> activity_subprocess[activity1, activity2, etc.] -> connector_follow $this->addClonedConnector($connector, $connector); } //glue segment: $glue = array_merge(array($activity), $allConnectors['prev']); foreach ($glue as $fragment) { $this->linkClonedStep($fragment); } //delete all activity: $activity->delete(true); //recursive call: foreach ($this->getClonedActivities() as $activityClone) { $this->flattenProcessActivity($activityClone); } } } }
/** * Short description of method createConnector * * @access public * @author Joel Bout, <*****@*****.**> * @param core_kernel_classes_Resource sourceStep * @param string label * @throws Exception * @return core_kernel_classes_Resource */ public function createConnector(core_kernel_classes_Resource $sourceStep, $label = '') { $returnValue = null; $label = empty($label) ? $sourceStep->getLabel() . "_c" : $label; $connectorClass = new core_kernel_classes_Class(CLASS_CONNECTORS); $returnValue = $connectorClass->createInstance($label, "created by ProcessService.Class"); if (is_null($returnValue)) { throw new Exception("the connector cannot be created for the activity {$sourceStep->getUri()}"); } $activityService = wfEngine_models_classes_ActivityService::singleton(); $connectorService = wfEngine_models_classes_ConnectorService::singleton(); //associate the connector to the activity $sourceStep->setPropertyValue(new core_kernel_classes_Property(PROPERTY_STEP_NEXT), $returnValue); //set the activity reference of the connector: $activityRefProp = new core_kernel_classes_Property(PROPERTY_CONNECTORS_ACTIVITYREFERENCE); if ($activityService->isActivity($sourceStep)) { $returnValue->setPropertyValue($activityRefProp, $sourceStep); } elseif ($connectorService->isConnector($sourceStep)) { $returnValue->setPropertyValue($activityRefProp, $sourceStep->getUniquePropertyValue($activityRefProp)); } else { throw new Exception("invalid resource type for the activity parameter: {$sourceStep->getUri()}"); } return $returnValue; }
/** * Test the sequential process execution: */ public function testVirtualSequencialProcess() { error_reporting(E_ALL); try { $roleService = wfEngine_models_classes_RoleService::singleton(); $authoringService = wfAuthoring_models_classes_ProcessService::singleton(); $activityService = wfEngine_models_classes_ActivityService::singleton(); $activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton(); $processExecutionService = wfEngine_models_classes_ProcessExecutionService::singleton(); $processVariableService = wfEngine_models_classes_VariableService::singleton(); //TEST PLAN : //INSTANCE_ACL_ROLE, $roleA //INSTANCE_ACL_ROLE_RESTRICTED_USER, $roleB //INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB (assigned dynamically via process var $role_processVar in activity1) //INSTANCE_ACL_USER, $user2 (assigned dynamically via process var $user_processVar in activity2) //INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB (assigned dynamically via process var $role_processVar in activity1) //INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY, $roleA //create roles and users: $wfRole = new core_kernel_classes_Resource(INSTANCE_ROLE_WORKFLOW); $roleA = $roleService->addRole('ACLTestCaseRoleA', $wfRole); $roleB = $roleService->addRole('ACLTestCaseRoleB', $wfRole); $roleC = $roleService->addRole('ACLTestCaseRoleC', $wfRole); list($usec, $sec) = explode(" ", microtime()); $users = array(); $users[0] = $usec; for ($i = 1; $i <= 6; $i++) { $users[] = 'ACLTestCaseUser' . $i . '-' . $usec; } $user1 = $this->createUser($users[1]); $user1->setLabel($users[1]); $user2 = $this->createUser($users[2]); $user2->setLabel($users[2]); $user3 = $this->createUser($users[3]); $user3->setLabel($users[3]); $user4 = $this->createUser($users[4]); $user4->setLabel($users[4]); $user5 = $this->createUser($users[5]); $user5->setLabel($users[5]); $user6 = $this->createUser($users[6]); $user6->setLabel($users[6]); $roleService->setRoleToUsers($roleA, array($user1->getUri(), $user2->getUri(), $user3->getUri())); $roleService->setRoleToUsers($roleB, array($user4->getUri(), $user5->getUri())); $roleService->setRoleToUsers($roleC, array($user6->getUri())); //create some process variables: $user_processVar_key = 'unit_var_user_' . time(); $user_processVar = $processVariableService->createProcessVariable('Proc Var for user assignation', $user_processVar_key); $role_processVar_key = 'unit_var_role_' . time(); $role_processVar = $processVariableService->createProcessVariable('Proc Var for role assignation', $role_processVar_key); //create a new process def $processDefinition = $authoringService->createProcess('ProcessForUnitTest', 'Unit test'); $this->assertIsA($processDefinition, 'core_kernel_classes_Resource'); //define activities and connectors //activity 1: $activity1 = $authoringService->createActivity($processDefinition, 'activity1'); $this->assertNotNull($activity1); $authoringService->setFirstActivity($processDefinition, $activity1); $activityService->setAcl($activity1, new core_kernel_classes_Resource(INSTANCE_ACL_ROLE), $roleA); $connector1 = $authoringService->createConnector($activity1); $authoringService->setConnectorType($connector1, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE)); $this->assertNotNull($connector1); //activity 2: $activity2 = $authoringService->createSequenceActivity($connector1, null, 'activity2'); $this->assertNotNull($activity2); $activityService->setAcl($activity2, new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER), $roleB); $connector2 = $authoringService->createConnector($activity2); $authoringService->setConnectorType($connector2, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE)); $this->assertNotNull($connector2); //activity 3: $activity3 = $authoringService->createSequenceActivity($connector2, null, 'activity3'); $this->assertNotNull($activity3); $activityService->setAcl($activity3, new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED), $role_processVar); $connector3 = $authoringService->createConnector($activity3); $authoringService->setConnectorType($connector3, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE)); $this->assertNotNull($connector3); //activity 4: $activity4 = $authoringService->createSequenceActivity($connector3, null, 'activity4'); $this->assertNotNull($activity4); $activityService->setAcl($activity4, new core_kernel_classes_Resource(INSTANCE_ACL_USER), $user_processVar); $connector4 = $authoringService->createConnector($activity4); $authoringService->setConnectorType($connector4, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE)); $this->assertNotNull($connector4); //activity 5: $activity5 = $authoringService->createSequenceActivity($connector4, null, 'activity5'); $this->assertNotNull($activity5); $activityService->setAcl($activity5, new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED), $role_processVar); $connector5 = $authoringService->createConnector($activity5); $authoringService->setConnectorType($connector5, new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_SEQUENCE)); $this->assertNotNull($connector5); //activity 6: $activity6 = $authoringService->createSequenceActivity($connector5, null, 'activity6'); $this->assertNotNull($activity6); $activityService->setAcl($activity6, new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY), $roleA); //run the process $processExecName = 'Test Process Execution'; $processExecComment = 'created for processExecustionService test case by ' . __METHOD__; $processInstance = $processExecutionService->createProcessExecution($processDefinition, $processExecName, $processExecComment); $this->assertEquals($processDefinition->getUri(), $processExecutionService->getExecutionOf($processInstance)->getUri()); $this->assertEquals($processDefinition->getUri(), $processExecutionService->getExecutionOf($processInstance)->getUri()); $this->assertTrue($processExecutionService->checkStatus($processInstance, 'started')); $this->out(__METHOD__, true); $currentActivityExecutions = $processExecutionService->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($currentActivityExecutions), 1); $this->assertEquals(strpos(array_pop($currentActivityExecutions)->getLabel(), 'Execution of activity1'), 0); $this->out("<strong>Forward transitions:</strong>", true); $loginProperty = new core_kernel_classes_Property(PROPERTY_USER_LOGIN); $iterationNumber = 6; $i = 1; while ($i <= $iterationNumber) { if ($i < $iterationNumber) { //try deleting a process that is not finished $this->assertFalse($processExecutionService->deleteProcessExecution($processInstance, true)); } $activities = $processExecutionService->getAvailableCurrentActivityDefinitions($processInstance, $this->currentUser); $this->assertEquals(count($activities), 1); $activity = array_shift($activities); $this->out("<strong>" . $activity->getLabel() . "</strong>", true); $this->assertTrue($activity->getLabel() == 'activity' . $i); $this->out("current user : "******"' . $this->currentUser->getUri() . '"', true); $activityExecutions = $processExecutionService->getCurrentActivityExecutions($processInstance); $activityExecution = reset($activityExecutions); $this->checkAccessControl($activityExecution); //check ACL: switch ($i) { case 1: //INSTANCE_ACL_ROLE, $roleA: $this->checkAclRole($users, $activityExecution, $processInstance); $processVariableService->push($role_processVar_key, $roleB->getUri()); break; case 2: //INSTANCE_ACL_ROLE_RESTRICTED_USER, $roleB: $this->checkAclRoleRestrictedUser($users, $activityExecution, $processInstance); $processVariableService->push($user_processVar_key, $user2->getUri()); break; case 3: //INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB $this->assertTrue($this->changeUser($users[5])); $this->assertTrue($activityExecutionService->checkAcl($activityExecution, $this->currentUser, $processInstance)); $this->assertNotNull($processExecutionService->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser)); $this->checkAclRoleRestrictedUserInherited($users, $activityExecution, $processInstance); break; case 4: //INSTANCE_ACL_USER, $user2: $this->checkAclUser($users, $activityExecution, $processInstance); break; case 5: //INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB: //only user5 can access it normally: $this->checkUser5($users, $activityExecution, $processInstance); break; case 6: //INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY, $roleA: //only the user of $roleA that executed (the initial acivity belongs to user2: $this->checkAclRoleRestrictedUserDelivery($users, $activityExecution, $processInstance); break; } //init execution $activityExecution = $processExecutionService->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser); $this->assertNotNull($activityExecution); $activityExecStatus = $activityExecutionService->getStatus($activityExecution); $this->assertNotNull($activityExecStatus); $this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED); //transition to next activity $transitionResult = $processExecutionService->performTransition($processInstance, $activityExecution); switch ($i) { case 1: case 3: case 4: case 5: $this->assertFalse(count($transitionResult) > 0); $this->assertTrue($processExecutionService->isPaused($processInstance)); break; case 2: $this->assertTrue(count($transitionResult) > 0); $this->assertFalse($processExecutionService->isPaused($processInstance)); break; case 6: $this->assertFalse(count($transitionResult) > 0); $this->assertTrue($processExecutionService->isFinished($processInstance)); break; } $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $processExecutionService->getStatus($processInstance)->getLabel()); $i++; } $this->assertTrue($processExecutionService->isFinished($processInstance)); $this->assertTrue($processExecutionService->resume($processInstance)); $this->out("<strong>Backward transitions:</strong>", true); $j = 0; while ($j < $iterationNumber) { $activitieExecs = $processExecutionService->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($activitieExecs), 1); $activityExecution = reset($activitieExecs); $activity = $activityExecutionService->getExecutionOf($activityExecution); $this->out("<strong>" . $activity->getLabel() . "</strong>", true); $index = $iterationNumber - $j; $this->assertEquals($activity->getLabel(), "activity{$index}"); $this->out("current user : "******"' . $this->currentUser->getUri() . '"', true); $this->checkAccessControl($activityExecution); //check ACL: switch ($index) { case 1: //INSTANCE_ACL_ROLE, $roleA: $this->checkAclRole($users, $activityExecution, $processInstance); break; case 2: //INSTANCE_ACL_ROLE_RESTRICTED_USER, $roleB: $this->checkAclRoleRestrictedUser($users, $activityExecution, $processInstance); break; case 3: //INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB $this->checkAclRoleRestrictedUserInherited($users, $activityExecution, $processInstance); break; case 4: //INSTANCE_ACL_USER, $user2: $this->checkAclUser($users, $activityExecution, $processInstance); break; case 5: //INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB: //only user5 can access it normally: $this->checkUser5($users, $activityExecution, $processInstance); break; case 6: //INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY, $roleA: //only the user of $roleA that executed (the initial acivity belongs to user2: $this->checkAclRoleRestrictedUserDelivery($users, $activityExecution, $processInstance); break; } //init execution $activityExecution = $processExecutionService->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser); $this->assertNotNull($activityExecution); $activityExecStatus = $activityExecutionService->getStatus($activityExecution); $this->assertNotNull($activityExecStatus); $this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED); //transition to next activity $transitionResult = $processExecutionService->performBackwardTransition($processInstance, $activityExecution); $processStatus = $processExecutionService->getStatus($processInstance); $this->assertNotNull($processStatus); $this->assertEquals($processStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED); if ($j < $iterationNumber - 1) { $this->assertTrue(count($transitionResult) > 0); } else { $this->assertFalse($transitionResult); } $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $processExecutionService->getStatus($processInstance)->getLabel()); $j++; } $this->out("<strong>Forward transitions again:</strong>", true); $i = 1; while ($i <= $iterationNumber) { if ($i < $iterationNumber) { //try deleting a process that is not finished $this->assertFalse($processExecutionService->deleteProcessExecution($processInstance, true)); } $activitieExecs = $processExecutionService->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($activitieExecs), 1); $activityExecution = reset($activitieExecs); $activity = $activityExecutionService->getExecutionOf($activityExecution); $this->out("<strong>" . $activity->getLabel() . "</strong>", true); $this->assertTrue($activity->getLabel() == 'activity' . $i); $this->checkAccessControl($activityExecution); //check ACL: switch ($i) { case 1: //INSTANCE_ACL_ROLE, $roleA: $this->checkAclRole($users, $activityExecution, $processInstance); //TODO:to be modified after "back" $processVariableService->push($role_processVar_key, $roleB->getUri()); break; case 2: //INSTANCE_ACL_ROLE_RESTRICTED_USER, $roleB: $this->checkAclRoleRestrictedUser($users, $activityExecution, $processInstance); //TODO:to be modified after "back" $processVariableService->push($user_processVar_key, $user2->getUri()); break; case 3: //INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB $this->checkAclRoleRestrictedUserInherited($users, $activityExecution, $processInstance); break; case 4: //INSTANCE_ACL_USER, $user2: $this->checkAclUser($users, $activityExecution, $processInstance); break; case 5: //INSTANCE_ACL_ROLE_RESTRICTED_USER_INHERITED, $roleB: //only user5 can access it normally: $this->checkUser5($users, $activityExecution, $processInstance); break; case 6: //INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY, $roleA: //only the user of $roleA that executed (the initial acivity belongs to user2: $this->checkAclRoleRestrictedUserDelivery($users, $activityExecution, $processInstance); break; } //init execution $activityExecution = $processExecutionService->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser); $this->assertNotNull($activityExecution); //transition to next activity $transitionResult = $processExecutionService->performTransition($processInstance, $activityExecution); switch ($i) { case 1: case 3: case 4: case 5: $this->assertFalse(count($transitionResult) > 0); $this->assertTrue($processExecutionService->isPaused($processInstance)); break; case 2: $this->assertTrue(count($transitionResult) > 0); $this->assertFalse($processExecutionService->isPaused($processInstance)); break; case 6: $this->assertFalse(count($transitionResult) > 0); $this->assertTrue($processExecutionService->isFinished($processInstance)); break; } $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $processExecutionService->getStatus($processInstance)->getLabel()); $i++; } $this->assertTrue($processExecutionService->isFinished($processInstance)); //delete processdef: $this->assertTrue($authoringService->deleteProcess($processDefinition)); //delete process execution: $this->assertTrue($processInstance->exists()); $this->assertTrue($processExecutionService->deleteProcessExecution($processInstance)); $this->assertFalse($processInstance->exists()); if (!is_null($this->currentUser)) { $this->userService->logout(); $this->userService->removeUser($this->currentUser); } $roleA->delete(); $roleB->delete(); $roleC->delete(); $user1->delete(); $user2->delete(); $user3->delete(); $user4->delete(); $user5->delete(); $user6->delete(); $user_processVar->delete(); $role_processVar->delete(); } catch (common_Exception $ce) { $this->fail($ce); } }
/** * Short description of method getConditionalConnectorNewActivities * * @access protected * @author Somsack Sipasseuth, <*****@*****.**> * @param Resource processExecution * @param Resource activityExecution * @param Resource conditionalConnector * @return array */ protected function getConditionalConnectorNewActivities(core_kernel_classes_Resource $processExecution, core_kernel_classes_Resource $activityExecution, core_kernel_classes_Resource $conditionalConnector) { $returnValue = array(); $activityService = wfEngine_models_classes_ActivityService::singleton(); $connectorService = wfEngine_models_classes_ConnectorService::singleton(); $transitionRuleService = wfEngine_models_classes_TransitionRuleService::singleton(); $transitionRule = $connectorService->getTransitionRule($conditionalConnector); if (is_null($transitionRule)) { return $returnValue; } $evaluationResult = $transitionRuleService->getExpression($transitionRule)->evaluate(array(VAR_PROCESS_INSTANCE => $activityExecution->getUri())); // var_dump('transition rule '.$transitionRule->getLabel(), $evaluationResult); if ($evaluationResult) { // next activities = THEN $thenActivity = $transitionRuleService->getThenActivity($transitionRule); if (!is_null($thenActivity)) { if ($activityService->isActivity($thenActivity)) { $thenActivity->getLabel(); $returnValue[] = $thenActivity; } else { if ($activityService->isConnector($thenActivity)) { $returnValue = $this->getNewActivities($processExecution, $activityExecution, $thenActivity); } } } else { throw new wfEngine_models_classes_ProcessDefinitonException('no "then" activity found for the transition rule ' . $transitionRule->getUri()); } // var_dump('then', $returnValue); } else { // next activities = ELSE $elseActivity = $transitionRuleService->getElseActivity($transitionRule); if (!is_null($elseActivity)) { if ($activityService->isActivity($elseActivity)) { $elseActivity->getLabel(); $returnValue[] = $elseActivity; } else { $returnValue = $this->getNewActivities($processExecution, $activityExecution, $elseActivity); } } else { throw new wfEngine_models_classes_ProcessDefinitonException('no "else" activity found for the transition rule ' . $transitionRule->getUri()); } // var_dump('else', $returnValue); } return (array) $returnValue; }
/** * Short description of method isActivityInitial * * @access public * @author Joel Bout, <*****@*****.**> * @param Resource activity * @return boolean */ public static function isActivityInitial(core_kernel_classes_Resource $activity) { $returnValue = (bool) false; $returnValue = wfEngine_models_classes_ActivityService::singleton()->isInitial($activity); return (bool) $returnValue; }
protected function assertCorresponds(core_kernel_classes_Resource $step1, core_kernel_classes_Resource $step2) { //echo 'Compare '.$step1->getLabel().' and '.$step2->getLabel().'<br />'; $services1 = wfEngine_models_classes_ActivityService::singleton()->getInteractiveServices($step1); $services2 = wfEngine_models_classes_ActivityService::singleton()->getInteractiveServices($step2); $this->assertEquals(count($services1), count($services2)); if (count($services1) == count($services2)) { foreach ($services1 as $service1) { $service2 = array_shift($services2); $call1 = tao_models_classes_service_ServiceCall::fromResource($service1); $call2 = tao_models_classes_service_ServiceCall::fromResource($service2); $this->assertEquals($call1->serializeToString(), $call2->serializeToString()); } } }
/** * Test the tokens into a parallel process */ public function testVirtualParallelJoinProcess() { error_reporting(E_ALL); $t_start = microtime(true); //init services $activityService = wfEngine_models_classes_ActivityService::singleton(); $processVariableService = wfEngine_models_classes_VariableService::singleton(); $authoringService = wfAuthoring_models_classes_ProcessService::singleton(); $activityExecutionService = wfEngine_models_classes_ActivityExecutionService::singleton(); $activityExecutionService->cache = (bool) self::SERVICE_CACHE; //process definition $processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS); $processDefinition = $processDefinitionClass->createInstance('PJ processForUnitTest_' . date(DATE_ISO8601), 'created for the unit test of process execution'); $this->assertNotNull($processDefinition); /* +---------------+ | activity 0 | +-------+-------+ | +---v---+ | c 0 | split +--+-+--+ | | 3 +---------+ +---------+ unit_var_12345678 | | +-------v--------+ +-------v------+ | activity 1 | | activity 2 | +-------+--------+ +--------+-----+ | | +--------+ +--------+ +--v----v--+ | c 2 | join +----+-----+ | +-------v--------+ | activity 3 | +----------------+ */ //activities definitions $activity0 = $authoringService->createActivity($processDefinition, 'activity0'); $this->assertNotNull($activity0); $connector0 = null; $authoringService->setFirstActivity($processDefinition, $activity0); $connector0 = $authoringService->createConnector($activity0); $connectorParallele = new core_kernel_classes_Resource(INSTANCE_TYPEOFCONNECTORS_PARALLEL); $authoringService->setConnectorType($connector0, $connectorParallele); $this->assertNotNull($connector0); $parallelActivity1 = $authoringService->createActivity($processDefinition, 'activity1'); $this->assertNotNull($parallelActivity1); $roleRestrictedUser = new core_kernel_classes_Resource(INSTANCE_ACL_ROLE_RESTRICTED_USER); $activityService->setAcl($parallelActivity1, $roleRestrictedUser, $this->testUserRole); //!!! it is mendatory to set the role restricted user ACL mode to make this parallel process test case work $connector1 = null; $connector1 = $authoringService->createConnector($parallelActivity1); $this->assertNotNull($connector1); $parallelActivity2 = $authoringService->createActivity($processDefinition, 'activity2'); $this->assertNotNull($parallelActivity2); $activityService->setAcl($parallelActivity2, $roleRestrictedUser, $this->testUserRole); //!!! it is mendatory to set the role restricted user ACL mode to make this parallel process test case work $connector2 = null; $connector2 = $authoringService->createConnector($parallelActivity2); $this->assertNotNull($connector2); //define parallel activities, first branch with constant cardinality value, while the second listens to a process variable: $parallelCount1 = 3; $parallelCount2 = 5; $parallelCount2_processVar_key = 'unit_var_' . time(); $parallelCount2_processVar = $processVariableService->createProcessVariable('Var for unit test', $parallelCount2_processVar_key); $prallelActivitiesArray = array($parallelActivity1->getUri() => $parallelCount1, $parallelActivity2->getUri() => $parallelCount2_processVar); $result = $authoringService->setParallelActivities($connector0, $prallelActivitiesArray); $this->assertTrue($result); //set several split variables: $splitVariable1_key = 'unit_split_var1_' . time(); $splitVariable1 = $processVariableService->createProcessVariable('Split Var1 for unit test', $splitVariable1_key); $splitVariable2_key = 'unit_split_var2_' . time(); $splitVariable2 = $processVariableService->createProcessVariable('Split Var2 for unit test', $splitVariable2_key); $splitVariablesArray = array($parallelActivity1->getUri() => array($splitVariable1), $parallelActivity2->getUri() => array($splitVariable1, $splitVariable2)); $connectorService = wfAuthoring_models_classes_ConnectorService::singleton(); $connectorService->setSplitVariables($connector0, $splitVariablesArray); $prallelActivitiesArray[$parallelActivity2->getUri()] = $parallelCount2; $joinActivity = $authoringService->createActivity($processDefinition, 'activity3'); //join parallel Activity 1 and 2 to "joinActivity" $connector1 = wfAuthoring_models_classes_ConnectorService::singleton()->createJoin(array($parallelActivity1, $parallelActivity2), $joinActivity); /* $authoringService->createJoinActivity($connector1, $joinActivity, '', $parallelActivity1); $authoringService->createJoinActivity($connector2, $joinActivity, '', $parallelActivity2); */ //run the process $processExecName = 'Test Parallel Process Execution'; $processExecComment = 'created for processExecustionService test case by ' . __METHOD__; $processInstance = $this->service->createProcessExecution($processDefinition, $processExecName, $processExecComment); $this->assertTrue($this->service->checkStatus($processInstance, 'started')); $this->out(__METHOD__, true); $this->out("<strong>Forward transitions:</strong>", true); $previousActivityExecution = null; $numberActivities = 2 + $parallelCount1 + $parallelCount2; $createdUsers = array(); $loginProperty = new core_kernel_classes_Property(PROPERTY_USER_LOGIN); for ($i = 1; $i <= $numberActivities; $i++) { $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $countActivities = count($activitieExecs); $activity = null; $activityExecution = null; if ($countActivities > 1) { //select one of the available activities in the parallel branch: foreach ($activitieExecs as $activityExecUri => $activityExec) { if (!$activityExecutionService->isFinished($activityExec)) { $activityDefinition = $activityExecutionService->getExecutionOf($activityExec); $activityUri = $activityDefinition->getUri(); if (isset($prallelActivitiesArray[$activityUri])) { if ($prallelActivitiesArray[$activityUri] > 0) { $prallelActivitiesArray[$activityUri]--; $activityExecution = $activityExec; $activity = $activityDefinition; break; } } } } } else { if ($countActivities == 1) { $activityExecution = reset($activitieExecs); $activity = $activityExecutionService->getExecutionOf($activityExecution); } else { $this->fail('no current activity definition found for the iteration ' . $i); } } $this->out("<strong> Iteration {$i} :</strong>", true); $this->out("<strong>" . (is_null($activity) ? 'null' : $activity->getLabel()) . "</strong> (among {$countActivities})"); //issue : no activity found for the last iteration... //init execution $activityExecution = $this->service->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser); $this->assertNotNull($activityExecution); if ($i == 1) { //set value of the parallel thread: $processVariableService->push($parallelCount2_processVar_key, $parallelCount2); //set some values to the split variables: $values1 = array(); for ($j = 1; $j <= $parallelCount1; $j++) { $values1[] = 'A' . $j; } $values2 = array(); for ($j = 1; $j <= $parallelCount2; $j++) { $values2[] = 'B' . $j; } $processVariableService->push($splitVariable1_key, serialize($values1)); $processVariableService->push($splitVariable2_key, serialize($values2)); } else { //check dispatched value: // $value1 = $processVariableService->get($splitVariable1_key); // $value2 = $processVariableService->get($splitVariable2_key); // var_dump($value1, $value2); } $activityExecStatus = $activityExecutionService->getStatus($activityExecution); $this->assertNotNull($activityExecStatus); $this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_STARTED); //transition to next activity $this->out("current user: "******"' . $this->currentUser->getUri() . '"'); $this->out("performing transition ..."); //transition to next activity $performed = $this->service->performTransition($processInstance, $activityExecution); if (!$performed) { $this->out('transition failed.'); } $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $this->service->getStatus($processInstance)->getLabel()); //try undoing the transition: switch ($i) { case 1: $this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution)); $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($activitieExecs), 1); $activityBis = $activityExecutionService->getExecutionOf(reset($activitieExecs)); $this->assertTrue($activity->getUri() == $activityBis->getUri()); $transitionResult = $this->service->performTransition($processInstance, $activityExecution); break; case 1 + $parallelCount1: $this->assertFalse($this->service->undoForwardTransition($processInstance, $activityExecution)); $history = $this->service->getExecutionHistory($processInstance); $this->assertEquals(count($history), 2 * ($parallelCount1 + $parallelCount2) + 1); //activity 1, 2(closed), 2, 3 and 4 $this->assertFalse($this->service->undoForwardTransition($processInstance, new core_kernel_classes_Resource(reset($history)))); $this->assertNotNull($previousActivityExecution); $this->assertFalse($this->service->undoForwardTransition($processInstance, $previousActivityExecution)); break; case 1 + $parallelCount1 + $parallelCount2: $this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution)); $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($activitieExecs), $parallelCount1 + $parallelCount2); $transitionResult = $this->service->performTransition($processInstance, $activityExecution); break; } $previousActivityExecution = $activityExecution; if ($this->service->isPaused($processInstance)) { //Login another user to execute parallel branch $this->userService->logout(); $this->out("logout " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"', true); list($usec, $sec) = explode(" ", microtime()); $login = '******' . $i . '-' . $usec; $pass = '******'; $userData = array(PROPERTY_USER_LOGIN => $login, PROPERTY_USER_PASSWORD => core_kernel_users_Service::getPasswordHash()->encrypt($pass), PROPERTY_USER_DEFLG => 'http://www.tao.lu/Ontologies/TAO.rdf#Lang' . DEFAULT_LANG, PROPERTY_USER_UILG => 'http://www.tao.lu/Ontologies/TAO.rdf#Lang' . DEFAULT_LANG, PROPERTY_USER_ROLES => INSTANCE_ROLE_WORKFLOW, RDFS_LABEL => $login); if (!$this->userService->loginAvailable($login)) { $this->fail('test login already taken'); } $otherUser = $this->testUserClass->createInstanceWithProperties($userData); $createdUsers[$otherUser->getUri()] = $otherUser; if ($this->userService->loginUser($login, $pass)) { $this->currentUser = $this->userService->getCurrentUser(); $this->out("new user logged in: " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"'); } else { $this->fail("unable to login user {$login}"); } } } $this->assertTrue($this->service->isFinished($processInstance)); $this->assertTrue($this->service->resume($processInstance)); $this->out("<strong>Backward transitions:</strong>", true); // var_dump($this->service->getAllActivityExecutions($processInstance)); $j = 0; $iterationNumber = 2; while ($j < $iterationNumber) { $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $activityExecution = null; $activity = null; switch ($j) { case 0: $this->assertEquals(count($activitieExecs), 1); //check $activityExecution = reset($activitieExecs); $activity = $activityExecutionService->getExecutionOf($activityExecution); break; case 1: $this->assertEquals(count($activitieExecs), $parallelCount1 + $parallelCount2); //check $activity = $parallelActivity2; foreach ($this->service->getCurrentActivityExecutions($processInstance, $activity) as $activityExec) { if ($activityExecutionService->getActivityExecutionUser($activityExec)->getUri() == $this->currentUser->getUri()) { $activityExecution = $activityExec; } } if (is_null($activityExecution)) { $activity = $parallelActivity1; foreach ($this->service->getCurrentActivityExecutions($processInstance, $activity) as $activityExec) { if ($activityExecutionService->getActivityExecutionUser($activityExec)->getUri() == $this->currentUser->getUri()) { $activityExecution = $activityExec; } } } $this->assertNotNull($activityExecution); break; } $this->out("<strong>" . $activity->getLabel() . "</strong>", true); //init execution $activityExecution = $this->service->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser); $this->assertNotNull($activityExecution); $activityExecStatus = $activityExecutionService->getStatus($activityExecution); $this->assertNotNull($activityExecStatus); $this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED); $this->out("current user: "******"' . $this->currentUser->getUri() . '"'); $this->out("performing transition ..."); //transition to next activity $transitionResult = $this->service->performBackwardTransition($processInstance, $activityExecution); if ($j == 0) { $this->assertTrue(count($transitionResult) > 0); } else { if ($j == $iterationNumber - 1) { //var_dump($transitionResult); $this->assertFalse($transitionResult); } } $processStatus = $this->service->getStatus($processInstance); $this->assertNotNull($processStatus); $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $processStatus->getLabel()); $this->assertEquals($processStatus->getUri(), INSTANCE_PROCESSSTATUS_PAUSED); $j++; } $this->out("<strong>Forward transitions again:</strong>", true); $currentActivityExecutions = $this->service->getCurrentActivityExecutions($processInstance); $currentActivityExecutionsCount = count($currentActivityExecutions); $this->assertEquals($currentActivityExecutionsCount, $parallelCount1 + $parallelCount2); for ($i = 0; $i < $currentActivityExecutionsCount; $i++) { $currentActivityExecution = array_pop($currentActivityExecutions); $user = $activityExecutionService->getActivityExecutionUser($currentActivityExecution); $activityDefinition = $activityExecutionService->getExecutionOf($currentActivityExecution); $this->assertNotNull($user); $this->assertNotNull($activityDefinition); if (!is_null($user) && !is_null($activityDefinition)) { $this->userService->logout(); $this->out("logout " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"', true); $login = (string) $user->getUniquePropertyValue($loginProperty); $pass = '******'; if ($this->userService->loginUser($login, $pass)) { $this->currentUser = $this->userService->getCurrentUser(); $this->out("new user logged in: " . $this->currentUser->getOnePropertyValue($loginProperty) . ' "' . $this->currentUser->getUri() . '"'); } else { $this->fail("unable to login user {$login}<br>"); } $iterationNo = $i + 1; $this->out("<strong>Iteration {$iterationNo}: " . $activityDefinition->getLabel() . "</strong>", true); //execute activity: $activityExecution = $this->service->initCurrentActivityExecution($processInstance, $currentActivityExecution, $this->currentUser); $this->assertNotNull($activityExecution); $activityExecStatus = $activityExecutionService->getStatus($activityExecution); $this->assertNotNull($activityExecStatus); $this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_RESUMED); //transition to next activity $this->out("current user: "******"' . $this->currentUser->getUri() . '"'); $this->out("performing transition ..."); //transition to next activity $this->service->performTransition($processInstance, $activityExecution); $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $this->service->getStatus($processInstance)->getLabel()); //try undoing the transition: if ($i < $currentActivityExecutionsCount - 1) { $this->assertFalse($this->service->undoForwardTransition($processInstance, $activityExecution)); } } } //try undoing the transition: $this->assertTrue($this->service->undoForwardTransition($processInstance, $activityExecution)); $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($activitieExecs), $parallelCount1 + $parallelCount2); $transitionResult = $this->service->performTransition($processInstance, $activityExecution); $this->assertEquals(count($transitionResult), 1); $activitieExecs = $this->service->getCurrentActivityExecutions($processInstance); $this->assertEquals(count($activitieExecs), 1); $activityExecution = reset($activitieExecs); $activity = $activityExecutionService->getExecutionOf($activityExecution); $this->assertEquals($activity->getUri(), $joinActivity->getUri()); $this->out("<strong>Executing last activity: " . $activity->getLabel() . "</strong>", true); //init execution $activityExecution = $this->service->initCurrentActivityExecution($processInstance, $activityExecution, $this->currentUser); $this->assertNotNull($activityExecution); $activityExecStatus = $activityExecutionService->getStatus($activityExecution); $this->assertNotNull($activityExecStatus); $this->assertEquals($activityExecStatus->getUri(), INSTANCE_PROCESSSTATUS_STARTED); //transition to next activity $this->out("current user: "******"' . $this->currentUser->getUri() . '"'); $this->out("performing transition ..."); //transition to next activity $this->service->performTransition($processInstance, $activityExecution); $this->out("activity status: " . $activityExecutionService->getStatus($activityExecution)->getLabel()); $this->out("process status: " . $this->service->getStatus($processInstance)->getLabel()); $this->assertTrue($this->service->isFinished($processInstance)); $t_end = microtime(true); $duration = $t_end - $t_start; $this->out('Elapsed time: ' . $duration . 's', true); $this->out('deleting created resources:', true); //delete process exec: $this->assertTrue($this->service->deleteProcessExecution($processInstance)); //delete processdef: $this->assertTrue($authoringService->deleteProcess($processDefinition)); $parallelCount2_processVar->delete(); //delete created users: foreach ($createdUsers as $createdUser) { $this->out('deleting ' . $createdUser->getLabel() . ' "' . $createdUser->getUri() . '"'); $this->assertTrue($this->userService->removeUser($createdUser)); } if (!is_null($this->currentUser)) { $this->userService->logout(); $this->userService->removeUser($this->currentUser); } }
public function index() { if (is_null($this->processExecution)) { common_Logger::w('ProcessBrowser invoked without processExecution'); $this->redirectToMain(); return; } if ($this->autoRedirecting) { $this->autoredirectToIndex(); return; } /* * @todo: clean usage * known use of Session::setAttribute("processUri") in: * - taoDelivery_actions_ItemDelivery::runner() * - tao_actions_Api::createAuthEnvironment() */ $this->setSessionAttribute("processUri", $this->processExecution->getUri()); //user data for browser view $userViewData = wfEngine_helpers_UsersHelper::buildCurrentUserForView(); $this->setData('userViewData', $userViewData); $browserViewData = array(); // general data for browser view. //init services: $userService = wfEngine_models_classes_UserService::singleton(); $activityService = wfEngine_models_classes_ActivityService::singleton(); $interactiveServiceService = wfEngine_models_classes_InteractiveServiceService::singleton(); //get current user: $currentUser = $userService->getCurrentUser(); if (is_null($currentUser)) { throw new wfEngine_models_classes_ProcessExecutionException("No current user found!"); } //get activity execution from currently available process definitions: $currentlyAvailableActivityExecutions = $this->processExecutionService->getAvailableCurrentActivityExecutions($this->processExecution, $currentUser, true); $activityExecution = null; if (count($currentlyAvailableActivityExecutions) == 0) { common_Logger::w('No available current activity exec found: no permission or issue in process execution'); $this->pause(); return; } else { if (!is_null($this->activityExecution) && $this->activityExecution instanceof core_kernel_classes_Resource) { foreach ($currentlyAvailableActivityExecutions as $availableActivityExec) { if ($availableActivityExec->getUri() == $this->activityExecution->getUri()) { $activityExecution = $this->processExecutionService->initCurrentActivityExecution($this->processExecution, $this->activityExecution, $currentUser); break; } } if (is_null($activityExecution)) { //invalid choice of activity execution: $this->activityExecution = null; // $invalidActivity = new core_kernel_classes_Resource($activityUri); // throw new wfEngine_models_classes_ProcessExecutionException("invalid choice of activity definition in process browser {$invalidActivity->getLabel()} ({$invalidActivity->getUri()}). \n<br/> The link may be outdated."); $this->autoredirectToIndex(); return; } } else { if (count($currentlyAvailableActivityExecutions) == 1) { $activityExecution = $this->processExecutionService->initCurrentActivityExecution($this->processExecution, reset($currentlyAvailableActivityExecutions), $currentUser); if (is_null($activityExecution)) { throw new wfEngine_models_classes_ProcessExecutionException('cannot initiate the activity execution of the unique next activity definition'); } } else { //count > 1: //parallel branch, ask the user to select activity to execute: common_Logger::i('Ask the user to select activity'); $this->pause(); return; } } } if (!is_null($activityExecution)) { $this->activityExecution = $activityExecution; $browserViewData[''] = $this->processExecution->getUri(); $browserViewData['activityExecutionUri'] = $activityExecution->getUri(); $this->activityExecutionService->createNonce($this->activityExecution); $browserViewData['activityExecutionNonce'] = $this->activityExecutionService->getNonce($activityExecution); //get interactive services (call of services): $activityDefinition = $this->activityExecutionService->getExecutionOf($activityExecution); $interactiveServices = $activityService->getInteractiveServices($activityDefinition); $services = array(); foreach ($interactiveServices as $interactiveService) { $serviceCallModel = tao_models_classes_service_ServiceCall::fromResource($interactiveService); $vars = $serviceCallModel->getRequiredVariables(); $parameters = array(); foreach ($vars as $variable) { $key = (string) $variable->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_PROCESSVARIABLES_CODE)); $value = $activityExecution->getOnePropertyValue(new core_kernel_classes_Property($variable)); if ($value instanceof core_kernel_classes_Resource) { $parameters[$key] = $value->getUri(); } elseif ($value instanceof core_kernel_classes_Literal) { $parameters[$key] = (string) $value; } } $serviceCallId = $activityExecution->getUri() . (count($interactiveServices) == 1 ? '' : $interactiveService->getUri()); $jsServiceApi = tao_helpers_ServiceJavascripts::getServiceApi($serviceCallModel, $serviceCallId, $parameters); $services[] = array('style' => $interactiveServiceService->getStyle($interactiveService), 'api' => $jsServiceApi); } $this->setData('services', $services); //set activity control: $controls = $activityService->getControls($activityDefinition); $browserViewData['controls'] = array('backward' => isset($controls[INSTANCE_CONTROL_BACKWARD]) ? (bool) $controls[INSTANCE_CONTROL_BACKWARD] : false, 'forward' => isset($controls[INSTANCE_CONTROL_FORWARD]) ? (bool) $controls[INSTANCE_CONTROL_FORWARD] : false); // If paused, resume it: if ($this->processExecutionService->isFinished($this->processExecution)) { $this->processExecutionService->resume($this->processExecution); } //get process definition: $processDefinition = $this->processExecutionService->getExecutionOf($this->processExecution); // Browser view main data. $browserViewData['processLabel'] = $processDefinition->getLabel(); $browserViewData['processExecutionLabel'] = $this->processExecution->getLabel(); $browserViewData['activityLabel'] = $activityDefinition->getLabel(); $browserViewData['processUri'] = $this->processExecution->getUri(); $browserViewData['active_Resource'] = "'" . $activityDefinition->getUri() . "'"; $browserViewData['isInteractiveService'] = true; $this->setData('browserViewData', $browserViewData); $this->setData('activity', $activityDefinition); /* <DEBUG> :populate the debug widget */ if (DEBUG_MODE) { $this->setData('debugWidget', DEBUG_MODE); $servicesResources = array(); foreach ($services as $service) { $servicesResource = $service; $servicesResource['input'] = $interactiveServiceService->getInputValues($interactiveService, $activityExecution); $servicesResource['output'] = $interactiveServiceService->getOutputValues($interactiveService, $activityExecution); $servicesResources[] = $servicesResource; } $variableService = wfEngine_models_classes_VariableService::singleton(); $this->setData('debugData', array('Activity' => $activityDefinition, 'ActivityExecution' => $activityExecution, 'CurrentActivities' => $currentlyAvailableActivityExecutions, 'Services' => $servicesResources, 'VariableStack' => $variableService->getAll())); } /* </DEBUG> */ $this->setData('activityExecutionUri', $browserViewData['activityExecutionUri']); $this->setData('processUri', $browserViewData['processUri']); $this->setData('activityExecutionNonce', $browserViewData['activityExecutionNonce']); $this->setData('client_config_url', $this->getClientConfigUrl()); $this->setView('process_browser.tpl'); } }
/** * Short description of method getAclMode * * @access public * @author Somsack Sipasseuth, <*****@*****.**> * @param Resource activityExecution * @return core_kernel_classes_Resource */ public function getAclMode(core_kernel_classes_Resource $activityExecution) { $returnValue = null; $aclMode = $activityExecution->getOnePropertyValue($this->ACLModeProperty); if ($aclMode instanceof core_kernel_classes_Resource) { $activityService = wfEngine_models_classes_ActivityService::singleton(); if (array_key_exists($aclMode->getUri(), $activityService->getAclModes())) { $returnValue = $aclMode; } } return $returnValue; }
public function testGetPreviousActivities() { /* * activity > connector1(COND) * -> THEN > thenConnector(SQ) * -> ELSE > elseConnector (SQ) * -> Act3 > connector2(PARA) * -> Act4 > connector3(JOIN) * -> Act5 > connector4(JOIN) * -> Acto6 * */ $connector1 = $this->authoringService->createConnector($this->activity); $then = $this->authoringService->createConditionalActivity($connector1, 'then'); //create "Activity_2" $thenConnector = $this->authoringService->createConnector($then, 'then Connector'); //create "Activity_2" $else = $this->authoringService->createConditionalActivity($connector1, 'else', null, '', true); //create another connector $elseConnector = $this->authoringService->createConnector($else, 'else Connector'); //create "Activity_2" $activity3 = $this->authoringService->createSequenceActivity($thenConnector, null, 'Act3'); $this->authoringService->createSequenceActivity($elseConnector, $activity3); $connector1PrevAct = $this->service->getPreviousActivities($connector1); $this->assertInternalType('array', $connector1PrevAct); $this->assertTrue(sizeof($connector1PrevAct) == 1); if (isset($connector1PrevAct[0]) && $connector1PrevAct[0] instanceof core_kernel_classes_Resource) { $this->assertTrue($connector1PrevAct[0]->getUri() == $this->activity->getUri()); } $elsePrevAct = $this->service->getPreviousActivities($elseConnector); $this->assertInternalType('array', $elsePrevAct); $this->assertTrue(sizeof($elsePrevAct) == 1); if (isset($elsePrevAct[0]) && $elsePrevAct[0] instanceof core_kernel_classes_Resource) { $this->assertTrue($elsePrevAct[0]->getUri() == $else->getUri()); } $thenPrevAct = $this->service->getPreviousActivities($thenConnector); $this->assertInternalType('array', $thenPrevAct); $this->assertTrue(sizeof($thenPrevAct) == 1); if (isset($thenPrevAct[0]) && $thenPrevAct[0] instanceof core_kernel_classes_Resource) { $this->assertTrue($thenPrevAct[0]->getUri() == $then->getUri()); } $myProcessVar1 = $this->variableService->getProcessVariable('myProcessVarCode1', true); $transitionRule = $this->authoringService->createTransitionRule($connector1, '^myProcessVarCode1 == 1'); $connector2 = $this->authoringService->createConnector($activity3); $activity4 = $this->authoringService->createActivity($this->processDefinition, 'activity4 for interactive service unit test'); $connector3 = $this->authoringService->createConnector($activity4); $activity5 = $this->authoringService->createActivity($this->processDefinition, 'activity5 for interactive service unit test'); $connector4 = $this->authoringService->createConnector($activity5); $newActivitiesArray = array($activity4->getUri() => 2, $activity5->getUri() => 3); $this->authoringService->setParallelActivities($connector2, $newActivitiesArray); $activity6 = $this->authoringService->createActivity($this->processDefinition); $connector3 = wfAuthoring_models_classes_ConnectorService::singleton()->createJoin(array($activity4, $activity5), $activity6); /* $activity6 = $this->authoringService->createJoinActivity($connector3, null, '', $activity4); $activity7 = $this->authoringService->createJoinActivity($connector4, $activity6, '', $activity5); */ $this->assertEquals(count($this->service->getNextActivities($connector2)), 2); $activity3PrevActi = $this->service->getPreviousActivities($connector2); $this->assertInternalType('array', $activity3PrevActi); $this->assertTrue(sizeof($activity3PrevActi) == 1); if (isset($activity3PrevActi[0]) && $activity3PrevActi[0] instanceof core_kernel_classes_Resource) { $this->assertTrue($activity3PrevActi[0]->getUri() == $activity3->getUri()); } $activity4PrevActi = $this->service->getPreviousSteps($connector3); $this->assertInternalType('array', $activity4PrevActi); $this->assertEquals(sizeof($activity4PrevActi), 2); $cardinalityService = wfEngine_models_classes_ActivityCardinalityService::singleton(); $prevActivitiesarrayCount = array(); foreach ($activity4PrevActi as $cardinality) { $this->assertTrue($cardinalityService->isCardinality($cardinality)); $activities = $cardinalityService->getPreviousSteps($cardinality); $this->assertEquals(count($activities), 1); $activity = current($activities); $keyExists = array_key_exists($activity->getUri(), $newActivitiesArray); $this->assertTrue($keyExists); if ($keyExists) { $prevActivitiesarrayCount[$activity->getUri()] = $cardinalityService->getCardinality($cardinality); } } $this->assertEquals($prevActivitiesarrayCount, $newActivitiesArray); $then->delete(true); $else->delete(true); $activity3->delete(true); $activity4->delete(true); $activity5->delete(true); $activity6->delete(true); $transitionRule->delete(true); $connector1->delete(true); $connector2->delete(true); $connector3->delete(true); $connector4->delete(true); }
/** * Short description of method __construct * * @access public * @author Joel Bout, <*****@*****.**> * @param Resource process * @return mixed */ public function __construct(core_kernel_classes_Resource $process) { $this->process = $process; $this->activityService = wfEngine_models_classes_ActivityService::singleton(); $this->connectorService = wfEngine_models_classes_ConnectorService::singleton(); $this->authoringService = wfAuthoring_models_classes_ProcessService::singleton(); parent::__construct(); }
public function testCreateConditionalActivity() { $activity1 = $this->authoringService->createActivity($this->proc, 'myActivity'); $connector1 = $this->authoringService->createConnector($activity1); $then = $this->authoringService->createConditionalActivity($connector1, 'then'); //create "Activity_2" $else = $this->authoringService->createConditionalActivity($connector1, 'else', null, '', true); //create another connector $this->assertEquals($connector1->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_TYPE))->getUri(), INSTANCE_TYPEOFCONNECTORS_CONDITIONAL); $activityService = wfEngine_models_classes_ActivityService::singleton(); $this->assertTrue($activityService->isActivity($then)); $connectorService = wfEngine_models_classes_ConnectorService::singleton(); $this->assertTrue($connectorService->isConnector($else)); $activity3 = $this->authoringService->createSequenceActivity($else, null, 'Act3'); $this->assertEquals($activity3->getLabel(), 'Act3'); $transitionRule = $connector1->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_TRANSITIONRULE)); $this->assertEquals($then->getUri(), $transitionRule->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_TRANSITIONRULES_THEN))->getUri()); $this->assertEquals($else->getUri(), $transitionRule->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_TRANSITIONRULES_ELSE))->getUri()); $myProcessVar1 = null; $myProcessVar1 = $this->variableService->getProcessVariable('myProcessVarCode1', true); $transitionRuleBis = $this->authoringService->createTransitionRule($connector1, '^myProcessVarCode1 == 1'); $this->assertEquals($transitionRule->getUri(), $transitionRuleBis->getUri()); $this->assertTrue($this->variableService->deleteProcessVariable('myProcessVarCode1')); }
public function testCreateCBAProcess() { if (!$this->createProcess) { return; } $authoringService = wfAuthoring_models_classes_ProcessService::singleton(); $activityService = wfEngine_models_classes_ActivityService::singleton(); $connectorService = wfAuthoring_models_classes_ConnectorService::singleton(); $processVariableService = wfEngine_models_classes_VariableService::singleton(); $cardinalityService = wfEngine_models_classes_ActivityCardinalityService::singleton(); //create some process variables: $varCodes = array('unitUri', 'countryCode', 'languageCode', 'npm', 'translatorsCount', 'translator', 'reconciler', 'verifier', 'translatorSelected', 'translationFinished', 'TDreview', 'layoutCheck', 'finalCheck', 'opticalCheck', 'TDsignOff', 'countrySignOff', 'xliff', 'vff', 'xliff_working', 'vff_working'); //"workingFiles" holds the working versions of the xliff and vff files, plus their revision number, in an serialized array() //during translation: workingFiles = array('user'=>#007, 'xliff' => array('uri' => #123456, 'revision'=>3), 'vff'=> array('uri' => #456789, 'revision'=>5)) $this->populateVariables($varCodes); $aclUser = new core_kernel_classes_Resource(INSTANCE_ACL_USER); $aclRole = new core_kernel_classes_Resource(INSTANCE_ACL_ROLE); $processDefinition = $authoringService->createProcess($this->processLabel['CBA'], 'For Unit test'); $this->assertIsA($processDefinition, 'core_kernel_classes_Resource'); //set process initialization rights: $this->assertTrue($authoringService->setAcl($processDefinition, $aclRole, $this->roles['consortium'])); //define activities and connectors //Select translators: $activitySelectTranslators = $authoringService->createActivity($processDefinition, 'Select Translator'); $this->assertNotNull($activitySelectTranslators); $authoringService->setFirstActivity($processDefinition, $activitySelectTranslators); $activityService->setAcl($activitySelectTranslators, $aclUser, $this->vars['npm']); $activityService->setControls($activitySelectTranslators, array(INSTANCE_CONTROL_FORWARD)); $connectorSelectTranslators = $authoringService->createConnector($activitySelectTranslators); $this->assertNotNull($connectorSelectTranslators); //translate: $activityTranslate = $authoringService->createActivity($processDefinition, 'Translate'); $this->assertNotNull($activityTranslate); $activityService->setAcl($activityTranslate, $aclUser, $this->vars['translator']); $activityService->setControls($activityTranslate, array(INSTANCE_CONTROL_FORWARD)); $result = $authoringService->setParallelActivities($connectorSelectTranslators, array($activityTranslate->getUri() => $this->vars['translatorsCount'])); $this->assertTrue($result); $this->assertTrue($connectorService->setSplitVariables($connectorSelectTranslators, array($activityTranslate->getUri() => $this->vars['translator']))); $nextActivities = $connectorService->getNextActivities($connectorSelectTranslators); $this->assertEqual(count($nextActivities), 1); $cardinality = reset($nextActivities); $this->assertTrue($cardinalityService->isCardinality($cardinality)); $this->assertEqual($cardinalityService->getDestination($cardinality)->getUri(), $activityTranslate->getUri()); $this->assertEqual($cardinalityService->getCardinality($cardinality)->getUri(), $this->vars['translatorsCount']->getUri()); $connectorTranslate = $authoringService->createConnector($activityTranslate); $this->assertNotNull($connectorTranslate); //reconciliation: $activityReconciliation = $authoringService->createJoinActivity($connectorTranslate, null, 'Reconciliation', $activityTranslate); $prevActivities = $connectorService->getPreviousActivities($connectorTranslate); $this->assertEqual(count($prevActivities), 1); $cardinality = reset($prevActivities); $this->assertTrue($cardinalityService->isCardinality($cardinality)); $this->assertEqual($cardinalityService->getSource($cardinality)->getUri(), $activityTranslate->getUri()); $this->assertEqual($cardinalityService->getCardinality($cardinality)->getUri(), $this->vars['translatorsCount']->getUri()); $this->assertNotNull($activityReconciliation); $activityService->setAcl($activityReconciliation, $aclUser, $this->vars['reconciler']); $activityService->setControls($activityReconciliation, array(INSTANCE_CONTROL_FORWARD)); $connectorReconciliation = $authoringService->createConnector($activityReconciliation); $this->assertNotNull($connectorReconciliation); //verify translations $activityVerifyTranslations = $authoringService->createSequenceActivity($connectorReconciliation, null, 'Verify Translations'); $this->assertNotNull($activityVerifyTranslations); $activityService->setAcl($activityVerifyTranslations, $aclUser, $this->vars['verifier']); $activityService->setControls($activityVerifyTranslations, array(INSTANCE_CONTROL_FORWARD)); $connectorVerifyTranslations = $authoringService->createConnector($activityVerifyTranslations); $this->assertNotNull($connectorVerifyTranslations); //correct verification $activityCorrectVerification = $authoringService->createSequenceActivity($connectorVerifyTranslations, null, 'Correct Verification Issues'); $this->assertNotNull($activityCorrectVerification); $activityService->setAcl($activityCorrectVerification, $aclUser, $this->vars['reconciler']); $activityService->setControls($activityCorrectVerification, array(INSTANCE_CONTROL_FORWARD)); $connectorCorrectVerification = $authoringService->createConnector($activityCorrectVerification); $this->assertNotNull($connectorCorrectVerification); //TD review : $activityTDreview = $authoringService->createSequenceActivity($connectorCorrectVerification, null, 'TD review'); $this->assertNotNull($activityTDreview); $activityService->setAcl($activityTDreview, $aclRole, $this->roles['testDeveloper']); $activityService->setControls($activityTDreview, array(INSTANCE_CONTROL_FORWARD)); $connectorTDreview = $authoringService->createConnector($activityTDreview); $this->assertNotNull($connectorTDreview); //if TD review not ok, return to correct verification issues: $transitionRule = $authoringService->createTransitionRule($connectorTDreview, '^TDreview == 1'); $this->assertNotNull($transitionRule); $activityCorrectVerificationBis = $authoringService->createConditionalActivity($connectorTDreview, 'else', $activityCorrectVerification); //if ^TDreview != 1 $this->assertEqual($activityCorrectVerification->getUri(), $activityCorrectVerificationBis->getUri()); //correct layout : $activityCorrectLayout = $authoringService->createConditionalActivity($connectorTDreview, 'then', null, 'Correct Layout Issues'); //if ^TDreview == 1 $this->assertNotNull($activityCorrectLayout); $activityService->setAcl($activityCorrectLayout, $aclRole, $this->roles['developer']); $activityService->setControls($activityCorrectLayout, array(INSTANCE_CONTROL_FORWARD)); $connectorCorrectLayout = $authoringService->createConnector($activityCorrectLayout); $this->assertNotNull($connectorCorrectLayout); //if correct layout needs verification : $transitionRule = $authoringService->createTransitionRule($connectorCorrectLayout, '^layoutCheck == 1'); $this->assertNotNull($transitionRule); $activityVerification = $authoringService->createConditionalActivity($connectorCorrectLayout, 'else', null, 'Verification Followup'); //if ^layoutCheck != 1 $this->assertNotNull($activityVerification); $activityService->setAcl($activityVerification, $aclUser, $this->vars['verifier']); $activityService->setControls($activityVerification, array(INSTANCE_CONTROL_FORWARD)); $connectorVerification = $authoringService->createConnector($activityVerification); $this->assertNotNull($connectorVerification); //final check : $activityFinalCheck = $authoringService->createConditionalActivity($connectorCorrectLayout, 'then', null, 'Final Check'); //if ^layoutCheck == 1 $this->assertNotNull($activityFinalCheck); $activityService->setAcl($activityFinalCheck, $aclRole, $this->roles['testDeveloper']); $activityService->setControls($activityFinalCheck, array(INSTANCE_CONTROL_FORWARD)); $connectorFinalCheck = $authoringService->createConnector($activityFinalCheck); $this->assertNotNull($connectorFinalCheck); //if final check ok, go to scoring definition : $transitionRule = $authoringService->createTransitionRule($connectorFinalCheck, '^finalCheck == 1'); $this->assertNotNull($transitionRule); $activityScoringDefinition = $authoringService->createConditionalActivity($connectorFinalCheck, 'then', null, 'Scoring Definition and Testing'); //if ^finalCheck == 1 $this->assertNotNull($activityScoringDefinition); $activityService->setAcl($activityScoringDefinition, $aclUser, $this->vars['reconciler']); $activityService->setControls($activityScoringDefinition, array(INSTANCE_CONTROL_FORWARD)); $connectorScoringDefinition = $authoringService->createConnector($activityScoringDefinition); $this->assertNotNull($connectorScoringDefinition); //if not ok, return to correct layout : $activityCorrectLayoutBis = $authoringService->createConditionalActivity($connectorFinalCheck, 'else', $activityCorrectLayout); //if ^finalCheck != 1 $this->assertEqual($activityCorrectLayout->getUri(), $activityCorrectLayoutBis->getUri()); //verification : $transitionRule = $authoringService->createTransitionRule($connectorVerification, '^opticalCheck == 1'); $this->assertNotNull($transitionRule); $activityFinalCheckBis = $authoringService->createConditionalActivity($connectorVerification, 'then', $activityFinalCheck); //if ^opticalCheck == 1 $this->assertEqual($activityFinalCheckBis->getUri(), $activityFinalCheck->getUri()); $activityCorrectLayoutBis = $authoringService->createConditionalActivity($connectorVerification, 'else', $activityCorrectLayout); //if ^opticalCheck != 1 $this->assertEqual($activityCorrectLayoutBis->getUri(), $activityCorrectLayout->getUri()); //scoring verification: $activityScoringVerification = $authoringService->createSequenceActivity($connectorScoringDefinition, null, 'Scoring Verification'); $this->assertNotNull($activityScoringVerification); $activityService->setAcl($activityScoringVerification, $aclUser, $this->vars['verifier']); $activityService->setControls($activityScoringVerification, array(INSTANCE_CONTROL_FORWARD)); $connectorScoringVerification = $authoringService->createConnector($activityScoringVerification); $this->assertNotNull($connectorScoringVerification); //final sign off : $activityTDSignOff = $authoringService->createSequenceActivity($connectorScoringVerification, null, 'Test Developer Sign Off'); $this->assertNotNull($activityTDSignOff); $activityService->setAcl($activityTDSignOff, $aclRole, $this->roles['testDeveloper']); $activityService->setControls($activityTDSignOff, array(INSTANCE_CONTROL_FORWARD)); $connectorTDSignOff = $authoringService->createConnector($activityTDSignOff); $this->assertNotNull($connectorTDSignOff); //link back to final check: $transitionRule = $authoringService->createTransitionRule($connectorTDSignOff, '^TDsignOff == 1'); $this->assertNotNull($transitionRule); $authoringService->createConditionalActivity($connectorTDSignOff, 'else', $activityFinalCheck); //sign off : $activityCountrySignOff = $authoringService->createConditionalActivity($connectorTDSignOff, 'then', null, 'Country Sign Off'); $activityService->setAcl($activityCountrySignOff, $aclUser, $this->vars['reconciler']); $activityService->setControls($activityCountrySignOff, array(INSTANCE_CONTROL_FORWARD)); //complete the process: $connectorCountrySignOff = $authoringService->createConnector($activityCountrySignOff); $this->assertNotNull($connectorCountrySignOff); $transitionRule = $authoringService->createTransitionRule($connectorCountrySignOff, '^countrySignOff == 1'); $this->assertNotNull($transitionRule); $activityFinal = $authoringService->createConditionalActivity($connectorCountrySignOff, 'then', null, 'Completed'); $activityService->setAcl($activityFinal, $aclUser, $this->vars['reconciler']); $activityService->setControls($activityFinal, array(INSTANCE_CONTROL_FORWARD)); $activityService->setHidden($activityFinal, true); $activityTDSignOffBis = $authoringService->createConditionalActivity($connectorCountrySignOff, 'else', $activityTDSignOff); $this->assertEqual($activityTDSignOff->getUri(), $activityTDSignOffBis->getUri()); //end of process definition $this->processDefinition['CBA'] = $processDefinition; }
/** * Helper for get test items * * @access public * @author Joel Bout, <*****@*****.**> * @param * Resource activity * @return core_kernel_classes_Resource */ protected function getItemByActivity(core_kernel_classes_Resource $activity) { $returnValue = null; $services = wfEngine_models_classes_ActivityService::singleton()->getInteractiveServices($activity); foreach ($services as $iService) { if (!$iService instanceof core_kernel_classes_Resource) { throw new common_exception_InconsistentData('Non resource service call found for activity ' . $activity->getUri()); } $serviceDefinition = $iService->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CALLOFSERVICES_SERVICEDEFINITION)); if ($serviceDefinition->getUri() == INSTANCE_ITEMCONTAINER_SERVICE) { $returnValue = $this->getItemByService($iService); break; } } return $returnValue; }
public static function nextActivityElements(core_kernel_classes_Resource $connector, $type, $allowCreation = true, $includeConnectors = true, $optionsWidget = 'Combobox') { $returnValue = array(); $authorizedOptionsWidget = array('Combobox', 'Checkbox'); if (!in_array($optionsWidget, $authorizedOptionsWidget)) { throw new Exception('Wrong type of widget'); return $returnValue; } $idPrefix = ''; $nextActivity = null; $propTransitionRule = new core_kernel_classes_Property(PROPERTY_CONNECTORS_TRANSITIONRULE); $propNextActivities = new core_kernel_classes_Property(PROPERTY_STEP_NEXT); //find the next activity if available switch (strtolower($type)) { case 'next': $nextActivityCollection = $connector->getPropertyValuesCollection($propNextActivities); foreach ($nextActivityCollection->getIterator() as $activity) { if ($activity instanceof core_kernel_classes_Resource) { $nextActivity = $activity; //we take the last one...(note: there should be only one though) } } $idPrefix = 'next'; break; case 'then': $transitionRuleCollection = $connector->getPropertyValuesCollection($propTransitionRule); foreach ($transitionRuleCollection->getIterator() as $transitionRule) { if ($transitionRule instanceof core_kernel_classes_Resource) { foreach ($transitionRule->getPropertyValuesCollection(new core_kernel_classes_Property(PROPERTY_TRANSITIONRULES_THEN))->getIterator() as $then) { if ($then instanceof core_kernel_classes_Resource) { $nextActivity = $then; } } } } $idPrefix = 'then'; break; case 'else': $transitionRuleCollection = $connector->getPropertyValuesCollection($propTransitionRule); foreach ($transitionRuleCollection->getIterator() as $transitionRule) { if ($transitionRule instanceof core_kernel_classes_Resource) { foreach ($transitionRule->getPropertyValuesCollection(new core_kernel_classes_Property(PROPERTY_TRANSITIONRULES_ELSE))->getIterator() as $else) { if ($else instanceof core_kernel_classes_Resource) { $nextActivity = $else; } } } } $idPrefix = 'else'; break; case 'parallel': $nextActivity = array(); $nextActivityCollection = $connector->getPropertyValuesCollection($propNextActivities); foreach ($nextActivityCollection->getIterator() as $cardinality) { if ($cardinality instanceof core_kernel_classes_Resource) { $nextActivity[] = $cardinality; } } $idPrefix = 'parallel'; break; case 'join': // should only have one following activity $nextActivity = $connector->getOnePropertyValue($propNextActivities); $idPrefix = $type; break; default: throw new Exception("unknown type for the next activity"); } $activityOptions = array(); $connectorOptions = array(); if ($allowCreation) { //create the activity label element (used only in case of new activity craetion) $elementActivityLabel = tao_helpers_form_FormFactory::getElement($idPrefix . "_activityLabel", 'Textbox'); $elementActivityLabel->setDescription(__('Label')); //add the "creating" option $activityOptions["newActivity"] = __("create new activity"); $connectorOptions["newConnector"] = __("create new connector"); } //the activity associated to the connector: $referencedActivity = $connector->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_ACTIVITYREFERENCE)); //mandatory property value, initiated at the connector creation if ($referencedActivity instanceof core_kernel_classes_Resource) { $processDefClass = new core_kernel_classes_Class(CLASS_PROCESS); $processes = $processDefClass->searchInstances(array(PROPERTY_PROCESS_ACTIVITIES => $referencedActivity->getUri()), array('like' => false)); if (count($processes) > 0) { $process = array_shift($processes); if (!empty($process)) { //get list of activities and connectors for the current process: $connectorClass = new core_kernel_classes_Class(CLASS_CONNECTORS); $processAuthoringService = wfAuthoring_models_classes_ProcessService::singleton(); $activities = $processAuthoringService->getActivitiesByProcess($process); foreach ($activities as $activityTemp) { //include activities options: $encodedUri = tao_helpers_Uri::encode($activityTemp->getUri()); $activityOptions[$encodedUri] = $activityTemp->getLabel(); if (strtolower($type) == 'parallel') { $elementHidden = tao_helpers_form_FormFactory::getElement("{$encodedUri}_num_hidden", 'Hidden'); $returnValue[$idPrefix . '_' . $activityTemp->getUri()] = $elementHidden; } //include connectors options: if ($includeConnectors) { $connectors = $connectorClass->searchInstances(array(PROPERTY_CONNECTORS_ACTIVITYREFERENCE => $activityTemp->getUri()), array('like' => false)); foreach ($connectors as $connectorTemp) { if ($connector->getUri() != $connectorTemp->getUri()) { $connectorOptions[tao_helpers_Uri::encode($connectorTemp->getUri())] = $connectorTemp->getLabel(); } } } } } } } //create the description element $elementDescription = tao_helpers_form_FormFactory::getElement($idPrefix, 'Free'); $elementDescription->setValue(strtoupper($type) . ' :'); //create the activity select element: $elementActivities = tao_helpers_form_FormFactory::getElement($idPrefix . "_activityUri", $optionsWidget); $elementActivities->setDescription(__('Activity')); $elementActivities->setOptions($activityOptions); $elementChoice = null; $elementConnectors = null; if ($includeConnectors) { //the default radio button to select between the 3 possibilities: $elementChoice = tao_helpers_form_FormFactory::getElement($idPrefix . "_activityOrConnector", 'Radiobox'); $elementChoice->setDescription(__('Activity or Connector')); $options = array("activity" => __("Activity"), "connector" => __("Connector")); $elementChoice->setOptions($options); //create the connector select element: $elementConnectors = tao_helpers_form_FormFactory::getElement($idPrefix . "_connectorUri", $optionsWidget); $elementConnectors->setDescription(__('Connector')); $elementConnectors->setOptions($connectorOptions); } if (!empty($nextActivity)) { if (is_array($nextActivity) && $optionsWidget == 'Checkbox') { if (strtolower($type) == 'parallel') { $cardinalityService = wfEngine_models_classes_ActivityCardinalityService::singleton(); foreach ($nextActivity as $cardinality) { $activity = $cardinalityService->getDestination($cardinality); $number = $cardinalityService->getCardinality($cardinality); if (isset($returnValue[$idPrefix . '_' . $activity->getUri()])) { $returnValue[$idPrefix . '_' . $activity->getUri()]->setValue($number instanceof core_kernel_classes_Resource ? tao_helpers_Uri::encode($number->getUri()) : intval($number)); } $elementActivities->setValue($activity->getUri()); //no need for tao_helpers_Uri::encode } } else { foreach ($nextActivity as $activity) { $elementActivities->setValue($activity->getUri()); //no need for tao_helpers_Uri::encode } } } elseif ($nextActivity instanceof core_kernel_classes_Resource) { $aService = wfEngine_models_classes_ActivityService::singleton(); if ($aService->isActivity($nextActivity)) { if ($includeConnectors) { $elementChoice->setValue("activity"); } $elementActivities->setValue($nextActivity->getUri()); //no need for tao_helpers_Uri::encode } $conmectorService = wfEngine_models_classes_ConnectorService::singleton(); if ($conmectorService->isConnector($nextActivity) && $includeConnectors) { $elementChoice->setValue("connector"); $elementConnectors->setValue($nextActivity->getUri()); } } } //put all elements in the return value: $returnValue[$idPrefix . '_description'] = $elementDescription; if ($includeConnectors) { $returnValue[$idPrefix . '_choice'] = $elementChoice; } $returnValue[$idPrefix . '_activities'] = $elementActivities; if ($allowCreation) { $returnValue[$idPrefix . '_label'] = $elementActivityLabel; } if ($includeConnectors) { $returnValue[$idPrefix . '_connectors'] = $elementConnectors; } return $returnValue; }
/** * Short description of method cloneProcessSegment * * @access protected * @author Joel Bout, <*****@*****.**> * @param Resource process * @param boolean addTransitionalActivity * @return core_kernel_classes_Array */ protected function cloneProcessSegment(core_kernel_classes_Resource $process, $addTransitionalActivity = false) { $returnValue = null; $steps = $this->cloneProcessContent($process); $in = array(); $out = array(); foreach ($steps as $activity) { if (!$this->activityService->isActivity($activity)) { continue; } if (wfEngine_models_classes_ActivityService::singleton()->isInitial($activity)) { $in[] = $activity; } $next = $activity->getOnePropertyValue(new core_kernel_classes_Property(PROPERTY_STEP_NEXT)); if (is_null($next)) { $out[] = $activity; } } if (count($in) != 1) { throw new common_exception_Error('Unsupported nr of initial activities ' . count($in) . ' for test ' . $process->getUri()); } $initialActivity = array_shift($in); $newFinalActivities = $out; if (is_null($initialActivity)) { throw new Exception('no initial activity found to the defined process segment'); } if (empty($newFinalActivities)) { //TODO: check that every connector has a following activity throw new Exception('no terminal activity found to the defined process segment'); } $newInitialActivity = $initialActivity; if ($addTransitionalActivity) { //echo "adding transitionnal actiivties"; //init the required properties: $propInitial = new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISINITIAL); $propHidden = new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISHIDDEN); $activityClass = new core_kernel_classes_Class(CLASS_ACTIVITIES); //build the $firstActivity: $firstActivity = $activityClass->createInstance("process_start ({$process->getLabel()})", "created by ProcessCloner.Class"); $firstActivity->editPropertyValues($propInitial, GENERIS_TRUE); //do set it here, the property will be modified automatically by create "following" activity $firstActivity->editPropertyValues($propHidden, GENERIS_TRUE); $connector = $this->authoringService->createConnector($firstActivity); //get the clone of the intiial acitivty: if (is_null($newInitialActivity)) { throw new Exception("the intial activity has not been cloned: {$initialActivity->getLabel()}({$initialActivity->getUri()})"); } $this->authoringService->createSequenceActivity($connector, $newInitialActivity); //this function also automatically set the former $iniitalAcitivty to "not initial" //TODO: rename the function createSequenceActivity to addSequenceActivity, clearer that way //build the last activity: $lastActivity = $activityClass->createInstance("process_end ({$process->getLabel()})", "created by ProcessCloner.Class"); $lastActivity->editPropertyValues($propHidden, GENERIS_TRUE); foreach ($newFinalActivities as $newActivity) { //TODO: determine if there is need for merging multiple instances of a parallelized activity that has not been merged $connector = $this->authoringService->createConnector($newActivity); $this->authoringService->createSequenceActivity($connector, $lastActivity); } $newInitialActivity = $firstActivity; $newFinalActivities = $lastActivity; $this->addClonedActivity($firstActivity); $this->addClonedActivity($lastActivity); } $returnValue = array('in' => $newInitialActivity, 'out' => $newFinalActivities); return $returnValue; }
/** * Short description of method activityNode * * @access public * @author Joel Bout, <*****@*****.**> * @param Resource activity * @param string nodeClass * @param boolean goto * @param array portInfo * @param string labelSuffix * @return array */ public function activityNode(core_kernel_classes_Resource $activity, $nodeClass = '', $goto = false, $portInfo = array(), $labelSuffix = '') { $returnValue = array(); $class = ''; $linkAttribute = 'id'; $activityService = wfEngine_models_classes_ActivityService::singleton(); $connectorService = wfEngine_models_classes_ConnectorService::singleton(); if ($activityService->isActivity($activity)) { $class = 'node-activity'; } elseif ($connectorService->isConnector($activity)) { $class = 'node-connector'; } else { return $returnValue; //unknown type } if ($goto) { $class .= "-goto"; $linkAttribute = "rel"; } if (empty($portInfo)) { $portInfo = array('id' => 0, 'label' => 'next', 'multiplicity' => 1); } else { if (!isset($portInfo['id'])) { $portInfo['id'] = 0; } if (!isset($portInfo['id'])) { $portInfo['label'] = 'next'; } if (!isset($portInfo['id'])) { $portInfo['multiplicity'] = 1; } } $returnValue = array('data' => $activity->getLabel() . ' ' . $labelSuffix, 'attributes' => array($linkAttribute => tao_helpers_Uri::encode($activity->getUri()), 'class' => $class), 'port' => $nodeClass, 'portData' => $portInfo); $returnValue = self::addNodePrefix($returnValue, $nodeClass); return (array) $returnValue; }
/** * Short description of method getInitialSteps * * @access public * @author Joel Bout, <*****@*****.**> * @param Resource process * @return array */ public function getInitialSteps(core_kernel_classes_Resource $process) { $returnValue = array(); foreach ($this->getActivitiesByProcess($process) as $activity) { if (wfEngine_models_classes_ActivityService::singleton()->isInitial($activity)) { $returnValue[] = $activity; } } return (array) $returnValue; }