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);
}
}
}
}
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);
}
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 deleteActivity
*
* @access public
* @author Joel Bout, <*****@*****.**>
* @param Resource activity
* @return boolean
*/
public function deleteActivity(core_kernel_classes_Resource $activity)
{
$returnValue = (bool) false;
$activityService = wfAuthoring_models_classes_ActivityService::singleton();
$returnValue = $activityService->delete($activity);
return (bool) $returnValue;
}
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);
}
