/**
* tests initialization
*/
public function setUp()
{
TaoPhpUnitTestRunner::initTest();
$processDefinitionClass = new core_kernel_classes_Class(CLASS_PROCESS);
$processDefinition = $processDefinitionClass->createInstance('process of Cloning UnitTest', 'created for the unit test of process cloner');
if ($processDefinition instanceof core_kernel_classes_Resource) {
$this->proc = $processDefinition;
}
$this->apiModel = core_kernel_impl_ApiModelOO::singleton();
$this->authoringService = wfAuthoring_models_classes_ProcessService::singleton();
$this->activityService = wfAuthoring_models_classes_ActivityService::singleton();
$this->connectorService = wfAuthoring_models_classes_ConnectorService::singleton();
$this->processCloner = new wfAuthoring_models_classes_ProcessCloner();
}
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);
}
}
}
}
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);
}
