fernando/luos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactoring Bpmn/Workflow handling layer (2nd commit)

Browse Source
This commit is contained in:
Erik Amaru Ortiz
2014-01-31 18:49:57 -04:00
parent 8ef25dcc5e
commit cf59ed1308
10 changed files with 506 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

280
workflow/engine/src/ProcessMaker/Project/Adapter/WorkflowProject.php
View File

@@ -1,35 +1,71 @@
<?php
namespace ProcessMaker\Project\Adapter;
use \Criteria;
use \ResultSet;
use \Process;
use \Tasks;
use \Task;
use \Route;
use \RoutePeer;
use ProcessMaker\Project\ProjectHandler;
use ProcessMaker\Util\Hash;
class WorkflowProject extends ProjectHandler
class WorkflowProject //extends ProjectHandler
{
protected $process;
protected $proUid;
public function create($data)
protected $properties = array();
protected $tasks = array();
protected $routes = array();
public function __construct($data = null)
{
if (! is_null($data)) {
$this->setProperties($data);
$this->create();
}
}
public function setProperties($properties)
{
$this->properties = $properties;
}
public function getProperties()
{
$process = new Process();
return $process->load($this->proUid);
}
public function getUid()
{
return $this->proUid;
}
public function create()
{
try {
// setting defaults
$data['TASKS'] = array_key_exists('TASKS', $data) ? $data['TASKS'] : array();
$data['ROUTES'] = array_key_exists('ROUTES', $data) ? $data['ROUTES'] : array();
$this->properties['PRO_UID'] = array_key_exists('PRO_UID', $this->properties)
? $this->properties['PRO_UID'] : Hash::generateUID();
$this->properties['USR_UID'] = array_key_exists('PRO_CREATE_USER', $this->properties)
? $this->properties['PRO_CREATE_USER'] : null;
$this->properties['PRO_CATEGORY'] = array_key_exists('PRO_CATEGORY', $this->properties)
? $this->properties['PRO_CATEGORY'] : '';
// Create project
$process = new Process();
$this->proUid = $process->create($data, false);
// Create project's tasks
foreach ($data['TASKS'] as $taskData) {
$this->addTask($taskData);
}
// Create project's routes
foreach ($data['ROUTES'] as $route) {
}
$this->proUid = $process->create($this->properties, false);
} catch (Exception $e) {
//throw new \RuntimeException($e);
@@ -39,19 +75,20 @@ class WorkflowProject extends ProjectHandler
}
}
public function update($prjUid, $data)
public function update()
{
// TODO: Implement update() method.
}
public function delete($prjUid)
public function delete()
{
// TODO: Implement delete() method.
}
public function load($prjUid)
public static function load($prjUid)
{
// TODO: Implement load() method.
$process = new Process();
return $process->load($prjUid);
}
/*
@@ -60,29 +97,216 @@ class WorkflowProject extends ProjectHandler
public function addTask($taskData)
{
// Setting defaults
$taskData['TAS_UID'] = array_key_exists('TAS_UID', $taskData) ? $taskData['TAS_UID'] : Hash::generateUID();
$taskData['PRO_UID'] = $this->proUid;
$task = new Task();
$task->create($taskData, false);
return $task->create($taskData, false);
}
public function updateTask($taskData)
public function updateTask($tasUid, $taskData)
{
# code...
$task = new Task();
$taskData['TAS_UID'] = $tasUid;
return $task->update($taskData);
}
public function removeTask($taskData)
public function removeTask($tasUid)
{
# code...
$task = new Task();
$task->remove($tasUid);
}
public function addRoute($value='')
public function getTask($tasUid)
{
# code...
$task = new Task();
return $task->load($tasUid);
}
public function removeRoute($value='')
public function getTasks()
{
# code...
if (empty($this->proUid)) {
return null;
}
$tasks = new Tasks();
return $tasks->getAllTasks($this->proUid);
}
public function setStartTask($tasUid)
{
$task = \TaskPeer::retrieveByPK($tasUid);
$task->setTasStart("TRUE");
$task->save();
}
public function setEndTask($tasUid)
{
$this->addSequentialRoute($tasUid, "-1", "SEQUENTIAL", true);
}
public function addSequentialRoute($fromTasUid, $toTasUid, $delete = null)
{
$this->addRoute($fromTasUid, $toTasUid, "SEQUENTIAL", $delete);
}
public function addSelectRoute($fromTasUid, array $toTasks, $delete = null)
{
foreach ($toTasks as $toTasUid) {
$this->addRoute($fromTasUid, $toTasUid, "SELECT", $delete);
}
}
public function addRoute($fromTasUid, $toTasUid, $type, $delete = null)
{
/*switch ($type) {
case 0:
$sType = 'SEQUENTIAL';
break;
case 1:
$sType = 'SELECT';
break;
case 2:
$sType = 'EVALUATE';
break;
case 3:
$sType = 'PARALLEL';
break;
case 4:
$sType = 'PARALLEL-BY-EVALUATION';
break;
case 5:
$sType = 'SEC-JOIN';
break;
case 8:
$sType = 'DISCRIMINATOR';
break;
default:
throw new \Exception("Invalid type code, given: $type, expected: integer [1...8]");
}
}*/
$validTypes = array("SEQUENTIAL", "SELECT", "EVALUATE", "PARALLEL", "PARALLEL-BY-EVALUATION", "SEC-JOIN", "DISCRIMINATOR");
if (! in_array($type, $validTypes)) {
throw new \Exception("Invalid Route type, given: $type, expected: [".implode(",", $validTypes)."]");
}
//if ($type != 0 && $type != 5 && $type != 8) {
if ($type != 'SEQUENTIAL' && $type != 'SEC-JOIN' && $type != 'DISCRIMINATOR') {
if ($this->getNumberOfRoutes($this->proUid, $fromTasUid, $toTasUid, $type) > 0) {
// die(); ????
throw new \RuntimeException("Unexpected behaviour");
}
//unset($aRow);
}
//if ($delete || $type == 0 || $type == 5 || $type == 8) {
if ($delete || $type == 'SEQUENTIAL' || $type == 'SEC-JOIN' || $type == 'DISCRIMINATOR') {
$oTasks = new Tasks();
$oTasks->deleteAllRoutesOfTask($this->proUid, $fromTasUid);
//$oTasks->deleteAllGatewayOfTask($this->proUid, $fromTasUid);
}
return $this->saveNewPattern($this->proUid, $fromTasUid, $toTasUid, $type, $delete);
}
public function updateRoute($rouUid, $routeData)
{
$route = new Route();
$routeData['ROU_UID'] = $rouUid;
$route->update($routeData);
}
public function removeRoute($rouUid)
{
$route = new Route();
return $route->remove($rouUid);
}
public function getRoute($rouUid)
{
$route = new Route();
return $route->load($rouUid);
}
/////////////////////////////////
/*
* Migrated from class.processMap.php class
*/
private function getNumberOfRoutes($sProcessUID = '', $sTaskUID = '', $sNextTask = '', $sType = '')
{
try {
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn('COUNT(*) AS ROUTE_NUMBER');
$oCriteria->add(RoutePeer::PRO_UID, $sProcessUID);
$oCriteria->add(RoutePeer::TAS_UID, $sTaskUID);
$oCriteria->add(RoutePeer::ROU_NEXT_TASK, $sNextTask);
$oCriteria->add(RoutePeer::ROU_TYPE, $sType);
$oDataset = RoutePeer::doSelectRS($oCriteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset->next();
$aRow = $oDataset->getRow();
return (int) $aRow['ROUTE_NUMBER'];
} catch (Exception $oError) {
throw ($oError);
}
}
private function saveNewPattern($sProcessUID = '', $sTaskUID = '', $sNextTask = '', $sType = '', $sDelete = '')
{
try {
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn('COUNT(*) AS ROUTE_NUMBER');
//$oCriteria->addSelectColumn('GAT_UID AS GATEWAY_UID');
$oCriteria->add(RoutePeer::PRO_UID, $sProcessUID);
$oCriteria->add(RoutePeer::TAS_UID, $sTaskUID);
$oCriteria->add(RoutePeer::ROU_TYPE, $sType);
$oDataset = RoutePeer::doSelectRS($oCriteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset->next();
$aRow = $oDataset->getRow();
$aFields['PRO_UID'] = $sProcessUID;
$aFields['TAS_UID'] = $sTaskUID;
$aFields['ROU_NEXT_TASK'] = $sNextTask;
$aFields['ROU_TYPE'] = $sType;
$aFields['ROU_CASE'] = (int) $aRow['ROUTE_NUMBER'] + 1;
//$sGatewayUID = $aRow['GATEWAY_UID'];
//if ($sDelete && $sGatewayUID != '') {
// $oGateway = new Gateway();
// $oGateway->remove($sGatewayUID);
//}
//Getting Gateway UID after saving gateway
//if($sType != 'SEQUENTIAL' && $sGatewayUID == '' && $sDelete == '1')
/*??? Maybe this is deprecated
if ($sType != 'SEQUENTIAL') {
$oProcessMap = new processMap();
$sGatewayUID = $this->saveNewGateway($sProcessUID, $sTaskUID, $sNextTask);
}*/
//$aFields['GAT_UID'] = (isset($sGatewayUID)) ? $sGatewayUID : '';
$oRoute = new Route();
return $oRoute->create($aFields);
} catch (Exception $oError) {
throw ($oError);
}
}
}

9
workflow/engine/src/ProcessMaker/Project/ProjectHandler.php
View File

@@ -3,12 +3,11 @@ namespace ProcessMaker\Project;
use ProcessMaker\Util\Logger;
abstract class ProjectHandler implements ProjectHandlerInterface
abstract class ProjectHandler //implements ProjectHandlerInterface
{
public abstract function create($data);
public abstract function update($prjUid, $data);
public abstract function delete($prjUid);
public abstract function load($prjUid);
public abstract function save();
public abstract function update();
public abstract function delete();
/**
* Log in ProcessMaker Standard Output if debug mode is enabled.

8
workflow/engine/src/ProcessMaker/Project/ProjectHandlerInterface.php
View File

@@ -3,8 +3,8 @@ namespace ProcessMaker\Project;
interface ProjectHandlerInterface
{
public function create($data);
public function update($prjUid, $data);
public function delete($prjUid);
public function load($prjUid);
public function save();
public function update();
public function delete();
public static function load();
}

246
workflow/engine/src/Tests/ProcessMaker/Adapter/WorkflowProjectTest.php
View File

@@ -1,6 +1,7 @@
<?php
if (! class_exists("Propel")) {
include_once "../../bootstrap.php";
include_once __DIR__ . "/../../bootstrap.php";
}
use \ProcessMaker\Project\Adapter\WorkflowProject;
@@ -18,26 +19,239 @@ class WorkflowProjectTest extends PHPUnit_Framework_TestCase
public function testCreate()
{
$data = array(
"PRO_UID" => "b72405854591363786050152eabf59dc",
"PRO_TITLE" => "Test Project #1",
"PRO_DESCRIPTION" => "Description for - Test Project #1",
"PRO_CATEGORY" => "",
"USR_UID" => "00000000000000000000000000000001",
"TASKS" => array(
array(
"TAS_UID" => "85459136378bf56050152ea9dcb72405",
"TAS_TITLE" => "task_1",
"TAS_POSX" => "50",
"TAS_POSY" => "50",
"TAS_WIDTH" => "100",
"TAS_HEIGHT" => "25"
)
),
"ROUTES" => array()
"PRO_CREATE_USER" => "00000000000000000000000000000001"
);
$result = $this->workflowProject->create($data);
$wp = new WorkflowProject($data);
var_dump($result);
$processData = $wp->getProperties();
foreach ($data as $key => $value) {
$this->assertEquals($data[$key], $processData[$key]);
}
return $wp;
}
/**
* @depends testCreate
*/
public function testAddTask($wp)
{
$data = array(
"TAS_TITLE" => "task #1",
"TAS_DESCRIPTION" => "Description for task #1",
"TAS_POSX" => "50",
"TAS_POSY" => "50",
"TAS_WIDTH" => "100",
"TAS_HEIGHT" => "25"
);
$tasUid = $wp->addTask($data);
$taskData = $wp->getTask($tasUid);
foreach ($data as $key => $value) {
$this->assertEquals($data[$key], $taskData[$key]);
}
}
/**
* @depends testCreate
*/
public function testUpdateTask($wp)
{
$data = array(
"TAS_TITLE" => "task #1 (updated)",
"TAS_POSX" => "150",
"TAS_POSY" => "250"
);
// at this time, there is only one task
$tasks = $wp->getTasks();
$this->assertInternalType('array', $tasks);
$this->assertCount(1, $tasks);
$wp->updateTask($tasks[0]['TAS_UID'], $data);
$taskData = $wp->getTask($tasks[0]['TAS_UID']);
foreach ($data as $key => $value) {
$this->assertEquals($data[$key], $taskData[$key]);
}
}
/**
* @depends testCreate
*/
public function testRemoveTask($wp)
{
$tasUid = $wp->addTask(array(
"TAS_TITLE" => "task #2",
"TAS_POSX" => "150",
"TAS_POSY" => "250"
));
$tasks = $wp->getTasks();
$this->assertInternalType('array', $tasks);
$this->assertCount(2, $tasks);
$wp->removeTask($tasUid);
$tasks = $wp->getTasks();
$this->assertInternalType('array', $tasks);
$this->assertCount(1, $tasks);
}
/**
* @depends testCreate
*/
public function testGetTasks($wp)
{
$tasUid1 = $wp->addTask(array(
"TAS_TITLE" => "task #2",
"TAS_POSX" => "250",
"TAS_POSY" => "250"
));
$tasUid2 = $wp->addTask(array(
"TAS_TITLE" => "task #3",
"TAS_POSX" => "350",
"TAS_POSY" => "350"
));
$tasks = $wp->getTasks();
$this->assertInternalType('array', $tasks);
$this->assertCount(3, $tasks);
$wp->removeTask($tasUid1);
$tasks = $wp->getTasks();
$this->assertInternalType('array', $tasks);
$this->assertCount(2, $tasks);
$wp->removeTask($tasUid2);
$tasks = $wp->getTasks();
$this->assertInternalType('array', $tasks);
$this->assertCount(1, $tasks);
$wp->removeTask($tasks[0]['TAS_UID']);
$tasks = $wp->getTasks();
$this->assertInternalType('array', $tasks);
$this->assertCount(0, $tasks);
}
/**
*
*/
public function testAddRoute()
{
$wp = new WorkflowProject(array(
"PRO_TITLE" => "Test Project #2 (Sequential)",
"PRO_CREATE_USER" => "00000000000000000000000000000001"
));
$tasUid1 = $wp->addTask(array(
"TAS_TITLE" => "task #1",
"TAS_POSX" => "410",
"TAS_POSY" => "61"
));
$tasUid2 = $wp->addTask(array(
"TAS_TITLE" => "task #2",
"TAS_POSX" => "159",
"TAS_POSY" => "370"
));
$rouUid = $wp->addRoute($tasUid1, $tasUid2, "SEQUENTIAL");
$routeSaved = $wp->getRoute($rouUid);
$this->assertEquals($tasUid1, $routeSaved['TAS_UID']);
$this->assertEquals($tasUid2, $routeSaved['ROU_NEXT_TASK']);
$this->assertEquals("SEQUENTIAL", $routeSaved['ROU_TYPE']);
}
public function testAddSelectRoute()
{
$wp = new WorkflowProject(array(
"PRO_TITLE" => "Test Project #3 (Select)",
"PRO_CREATE_USER" => "00000000000000000000000000000001"
));
$tasUid1 = $wp->addTask(array(
"TAS_TITLE" => "task #1",
"TAS_POSX" => "410",
"TAS_POSY" => "61"
));
$tasUid2 = $wp->addTask(array(
"TAS_TITLE" => "task #2",
"TAS_POSX" => "159",
"TAS_POSY" => "370"
));
$tasUid3 = $wp->addTask(array(
"TAS_TITLE" => "task #3",
"TAS_POSX" => "670",
"TAS_POSY" => "372"
));
$wp->addSelectRoute($tasUid1, array($tasUid2, $tasUid3));
}
public function testCompleteWorkflowProject()
{
$wp = new WorkflowProject(array(
"PRO_TITLE" => "Test Complete Project #4",
"PRO_CREATE_USER" => "00000000000000000000000000000001"
));
$tasUid1 = $wp->addTask(array(
"TAS_TITLE" => "task #1",
"TAS_POSX" => "406",
"TAS_POSY" => "71"
));
$tasUid2 = $wp->addTask(array(
"TAS_TITLE" => "task #2",
"TAS_POSX" => "188",
"TAS_POSY" => "240"
));
$tasUid3 = $wp->addTask(array(
"TAS_TITLE" => "task #3",
"TAS_POSX" => "406",
"TAS_POSY" => "239"
));
$tasUid4 = $wp->addTask(array(
"TAS_TITLE" => "task #4",
"TAS_POSX" => "294",
"TAS_POSY" => "366"
));
$tasUid5 = $wp->addTask(array(
"TAS_TITLE" => "task #5",
"TAS_POSX" => "640",
"TAS_POSY" => "240"
));
$tasUid6 = $wp->addTask(array(
"TAS_TITLE" => "task #6",
"TAS_POSX" => "640",
"TAS_POSY" => "359"
));
$wp->addRoute($tasUid1, $tasUid2, "PARALLEL");
$wp->addRoute($tasUid1, $tasUid3, "PARALLEL");
$wp->addRoute($tasUid1, $tasUid5, "PARALLEL");
$wp->addRoute($tasUid2, $tasUid4, "SEC-JOIN");
$wp->addRoute($tasUid3, $tasUid4, "SEC-JOIN");
$wp->addRoute($tasUid5, $tasUid6, "EVALUATE");
$wp->addRoute($tasUid5, "-1", "EVALUATE");
$wp->setStartTask($tasUid1);
$wp->setEndTask($tasUid4);
$wp->setEndTask($tasUid6);
}
}

5
workflow/engine/src/Tests/pm-bootstrap.php
View File

@@ -3,7 +3,8 @@
// pm-bootstrap.php
//
$config = parse_ini_file("config.ini");
$config = parse_ini_file(__DIR__ . DIRECTORY_SEPARATOR . "config.ini");
$workspace = $config['workspace'];
$lang = $config['lang'];
$processMakerHome = $config['pm_home_dir'];
@@ -132,7 +133,7 @@ if (is_file(PATH_DATA_SITE.PATH_SEP . '.server_info')) {
// create memcached singleton
Bootstrap::LoadClass( 'memcached' );
$memcache = PMmemcached::getSingleton( SYS_SYS );
//$memcache = PMmemcached::getSingleton( SYS_SYS );
Propel::init(PATH_CONFIG . "databases.php");