public function testIsolatedActivity() { $processChecker = new wfAuthoring_models_classes_ProcessChecker($this->proc); $activity1 = $this->authoringService->createActivity($this->proc); $connector1 = $this->authoringService->createConnector($activity1); $activity2 = $this->authoringService->createSequenceActivity($connector1); $this->assertTrue($processChecker->checkNoIsolatedActivity()); wfAuthoring_models_classes_ConnectorService::singleton()->delete($connector1); $this->assertFalse($processChecker->checkNoIsolatedActivity()); }
public function testSplitJoinVariable() { $process = wfAuthoring_models_classes_ProcessService::singleton()->createProcess('test process for ' . __FUNCTION__); $activityAuthoring = wfAuthoring_models_classes_ActivityService::singleton(); $webservice = new core_kernel_classes_Resource('http://www.tao.lu/Ontologies/TAODelivery.rdf#ServiceWebService'); $activity = array(); for ($i = 1; $i <= 3; $i++) { $activity[$i] = $activityAuthoring->createFromServiceDefinition($process, $webservice, array()); } wfAuthoring_models_classes_ProcessService::singleton()->setFirstActivity($process, $activity[1]); $c1 = $this->service->createSplit($activity[1], array($activity[2])); $c2 = $this->service->createJoin(array($activity[2]), $activity[3]); $this->service->setSplitCardinality($c1, array($activity[2]->getUri() => '3')); $this->service->setJoinCardinality($c2, array($activity[2]->getUri() => '3')); $this->runProcess($process, 5); wfAuthoring_models_classes_ProcessService::singleton()->deleteProcess($process); }
public function testCloneConditionnalProcess() { $this->processCloner->initCloningVariables(); $id = "P_condProc7_"; //for var_dump identification $this->processCloner->setCloneLabel("__Clone7"); $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 // $else1 = $this->authoringService->createConditionalActivity($connector1, 'else'); $this->assertEquals($connector1->getUniquePropertyValue(new core_kernel_classes_Property(PROPERTY_CONNECTORS_TYPE))->getUri(), INSTANCE_TYPEOFCONNECTORS_CONDITIONAL); $this->assertTrue($this->activityService->isActivity($then1)); $this->assertTrue($this->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()); //clone the process now! $processClone = $this->processCloner->cloneProcess($this->proc); $this->assertIsA($processClone, 'core_kernel_classes_Resource'); $this->assertEquals(count($this->processCloner->getClonedActivities()), 3); $this->assertEquals(count($this->processCloner->getClonedConnectors()), 3); //count the number of activities in the cloned process $activities = $this->authoringService->getActivitiesByProcess($processClone); $this->assertEquals(count($activities), 3); foreach ($activities as $activity) { $this->assertTrue($this->activityService->isActivity($activity)); } $this->authoringService->deleteProcess($processClone); }
/** * 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); } }
protected function createLinearSuperProcess($processes) { $processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS); $processDefinition = $processDefinitionClass->createInstance('process for ' . __CLASS__); $this->assertIsA($processDefinition, 'core_kernel_classes_Resource'); $activityService = wfAuthoring_models_classes_ActivityService::singleton(); $connectorService = wfAuthoring_models_classes_ConnectorService::singleton(); $processRunnerService = new core_kernel_classes_Resource(INSTANCE_SERVICE_PROCESSRUNNER); $processRunnerParam = new core_kernel_classes_Resource(INSTANCE_FORMALPARAM_PROCESSDEFINITION); $last = null; foreach ($processes as $subProcess) { $serviceCall = new tao_models_classes_service_ServiceCall($processRunnerService); $serviceCall->addInParameter(new tao_models_classes_service_ConstantParameter($processRunnerParam, $subProcess)); $current = $activityService->createActivity($processDefinition); $current->setPropertyValue(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_INTERACTIVESERVICES), $serviceCall->toOntology()); if (is_null($last)) { $current->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISINITIAL), GENERIS_TRUE); } else { $connectorService->createSequential($last, $current); } $last = $current; } return $processDefinition; }
/** * Short description of method setConnectorType * * @access public * @author Joel Bout, <*****@*****.**> * @param Resource connector * @param Resource type * @return boolean */ public function setConnectorType(core_kernel_classes_Resource $connector, core_kernel_classes_Resource $type) { $returnValue = (bool) false; $connectorService = wfAuthoring_models_classes_ConnectorService::singleton(); $returnValue = $connectorService->setConnectorType($connector, $type); return (bool) $returnValue; }
/** * Short description of method setTestItems * * @access public * @author Joel Bout, <*****@*****.**> * @param * Resource test * @param * array items * @return boolean */ public function setTestItems(core_kernel_classes_Resource $test, $items) { $returnValue = (bool) false; $authoringService = wfAuthoring_models_classes_ProcessService::singleton(); // get the current process: $process = $test->getUniquePropertyValue(new core_kernel_classes_Property(TEST_TESTCONTENT_PROP)); // get formal param associated to the 3 required service input parameters: $itemUriParam = new core_kernel_classes_Resource(INSTANCE_FORMALPARAM_ITEMURI); // delete all related activities: $activities = $authoringService->getAllActivities($process); foreach ($activities as $activity) { if (!$authoringService->deleteActivity($activity)) { throw new common_exception_Error('Unable to delete Activity ' . $activity->getUri()); } } // create the list of activities and interactive services and items plus their appropriate property values: $previousActivity = null; $connectorService = wfAuthoring_models_classes_ConnectorService::singleton(); foreach ($items as $item) { if (!$item instanceof core_kernel_classes_Resource) { throw new common_Exception("An item provided to " . __FUNCTION__ . " is not a resource but " . gettype($item)); } // create an activity $activity = null; $activity = $authoringService->createActivity($process, "item: {$item->getLabel()}"); // set property value visible to true $activity->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISHIDDEN), GENERIS_FALSE); // set ACL mode to role user restricted with role=subject $extManager = common_ext_ExtensionsManager::singleton(); $activity->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ACL_MODE), INSTANCE_ACL_ROLE_RESTRICTED_USER_DELIVERY); $activity->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_RESTRICTED_ROLE), INSTANCE_ROLE_DELIVERY); // get the item runner service definition: must exists! $itemRunnerServiceDefinition = new core_kernel_classes_Resource(INSTANCE_ITEMCONTAINER_SERVICE); if (!$itemRunnerServiceDefinition->exists()) { throw new common_exception_InconsistentData('required service definition item runner does not exists'); } // create a call of service and associate the service definition to it: $interactiveService = $authoringService->createInteractiveService($activity); $interactiveService->setPropertyValue(new core_kernel_classes_Property(PROPERTY_CALLOFSERVICES_SERVICEDEFINITION), $itemRunnerServiceDefinition->getUri()); $authoringService->setActualParameter($interactiveService, $itemUriParam, $item->getUri(), PROPERTY_CALLOFSERVICES_ACTUALPARAMETERIN); // constant: we know it! if (!is_null($previousActivity)) { $connectorService->createSequential($previousActivity, $activity); } else { // set the property value as initial $activity->editPropertyValues(new core_kernel_classes_Property(PROPERTY_ACTIVITIES_ISINITIAL), GENERIS_TRUE); } $previousActivity = $activity; } $returnValue = true; return (bool) $returnValue; }
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; }
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 delete * * @access public * @author Joel Bout, <*****@*****.**> * @param Resource activity * @return boolean */ public function delete(core_kernel_classes_Resource $activity) { $returnValue = (bool) false; $connectorService = wfAuthoring_models_classes_ConnectorService::singleton(); $interactiveServiceService = wfEngine_models_classes_InteractiveServiceService::singleton(); $connectorClass = new core_kernel_classes_Class(CLASS_CONNECTORS); $connectors = $connectorClass->searchInstances(array(PROPERTY_CONNECTORS_ACTIVITYREFERENCE => $activity->getUri()), array('like' => false, 'recursive' => 0)); foreach ($connectors as $connector) { $connectorService->delete($connector); } //deleting resource "acitivty" with its references should be enough normally to remove all references... to be tested //delete call of service!! foreach ($this->getInteractiveServices($activity) as $service) { $interactiveServiceService->deleteInteractiveService($service); } //delete referenced actiivty cardinality resources: $activityCardinalityClass = new core_kernel_classes_Class(CLASS_ACTIVITYCARDINALITY); $cardinalities = $activityCardinalityClass->searchInstances(array(PROPERTY_STEP_NEXT => $activity->getUri()), array('like' => false)); foreach ($cardinalities as $cardinality) { $cardinality->delete(true); } //delete activity itself: $returnValue = $activity->delete(true); return (bool) $returnValue; }