711 lines
27 KiB
PHP
711 lines
27 KiB
PHP
<?php
|
|
namespace ProcessMaker\Project\Adapter;
|
|
|
|
use ProcessMaker\Project;
|
|
use ProcessMaker\Util;
|
|
|
|
/**
|
|
* Class BpmnWorkflow
|
|
*
|
|
* @package ProcessMaker\Project\Adapter
|
|
* @author Erik Amaru Ortiz <aortiz.erik@gmail.com, erik@colosa.com>
|
|
*/
|
|
class BpmnWorkflow extends Project\Bpmn
|
|
{
|
|
/**
|
|
* @var \ProcessMaker\Project\Workflow
|
|
*/
|
|
protected $wp;
|
|
|
|
const BPMN_GATEWAY_COMPLEX = "COMPLEX";
|
|
const BPMN_GATEWAY_PARALLEL = "PARALLEL";
|
|
const BPMN_GATEWAY_INCLUSIVE = "INCLUSIVE";
|
|
const BPMN_GATEWAY_EXCLUSIVE = "EXCLUSIVE";
|
|
|
|
|
|
/**
|
|
* OVERRIDES
|
|
*/
|
|
|
|
public static function load($prjUid)
|
|
{
|
|
|
|
$parent = parent::load($prjUid);
|
|
//return new BpmnWorkflow();
|
|
|
|
$me = new BpmnWorkflow();
|
|
|
|
$me->project = $parent->project;
|
|
$me->prjUid = $parent->project->getPrjUid();
|
|
$me->wp = Project\Workflow::load($me->prjUid);
|
|
|
|
return $me;
|
|
}
|
|
|
|
public function create($data)
|
|
{
|
|
try {
|
|
parent::create($data);
|
|
} catch (\Exception $e) {
|
|
throw new \RuntimeException(sprintf("Can't create Bpmn Project." . PHP_EOL . $e->getMessage()));
|
|
}
|
|
|
|
try {
|
|
$wpData = array();
|
|
$wpData["PRO_UID"] = $this->getUid();
|
|
|
|
if (array_key_exists("PRJ_NAME", $data)) {
|
|
$wpData["PRO_TITLE"] = $data["PRJ_NAME"];
|
|
}
|
|
if (array_key_exists("PRJ_DESCRIPTION", $data)) {
|
|
$wpData["PRO_DESCRIPTION"] = $data["PRJ_DESCRIPTION"];
|
|
}
|
|
if (array_key_exists("PRJ_AUTHOR", $data)) {
|
|
$wpData["PRO_CREATE_USER"] = $data["PRJ_AUTHOR"];
|
|
}
|
|
|
|
$this->wp = new Project\Workflow();
|
|
$this->wp->create($wpData);
|
|
|
|
} catch (\Exception $e) {
|
|
$prjUid = $this->getUid();
|
|
//$this->remove();
|
|
$bpmnProject = Project\Bpmn::load($prjUid);
|
|
$bpmnProject->remove();
|
|
|
|
throw new \RuntimeException(sprintf(
|
|
"Can't create Bpmn Project with prj_uid: %s, workflow creation fails." . PHP_EOL . $e->getMessage()
|
|
, $prjUid
|
|
));
|
|
}
|
|
}
|
|
|
|
public static function getList($start = null, $limit = null, $filter = "", $changeCaseTo = CASE_UPPER)
|
|
{
|
|
$bpmnProjects = parent::getList($start, $limit, $filter);
|
|
$workflowProjects = Project\Workflow::getList($start, $limit, $filter);
|
|
$bpmnProjectsUid = array();
|
|
$bpmnProjectsList = array();
|
|
$list = array();
|
|
|
|
foreach ($bpmnProjects as $bpmnProject) {
|
|
$bpmnProjectsList[$bpmnProject["PRJ_UID"]] = $bpmnProject;
|
|
}
|
|
|
|
$bpmnProjectsUid = array_keys($bpmnProjectsList);
|
|
|
|
foreach ($workflowProjects as $workflowProject) {
|
|
$data["PRJ_UID"] = $workflowProject["PRO_UID"];
|
|
$data["PRJ_NAME"] = $workflowProject["PRO_TITLE"];
|
|
$data["PRJ_DESCRIPTION"] = $workflowProject["PRO_DESCRIPTION"];
|
|
$data["PRJ_CATEGORY"] = $workflowProject["PRO_CATEGORY"];
|
|
|
|
if (in_array($workflowProject["PRO_UID"], $bpmnProjectsUid)) {
|
|
$data["PRJ_TYPE"] = "bpmn";
|
|
$data["PRJ_CREATE_DATE"] = $bpmnProjectsList[$workflowProject["PRO_UID"]]["PRJ_CREATE_DATE"];
|
|
$data["PRJ_UPDATE_DATE"] = $bpmnProjectsList[$workflowProject["PRO_UID"]]["PRJ_UPDATE_DATE"];
|
|
} else {
|
|
$data["PRJ_TYPE"] = "classic";
|
|
$data["PRJ_CREATE_DATE"] = $workflowProject["PRO_CREATE_DATE"];
|
|
$data["PRJ_UPDATE_DATE"] = $workflowProject["PRO_UPDATE_DATE"];
|
|
}
|
|
|
|
if ($changeCaseTo != CASE_UPPER) {
|
|
$data = array_change_key_case($data, $changeCaseTo);
|
|
}
|
|
|
|
$list[] = $data;
|
|
}
|
|
|
|
return $list;
|
|
}
|
|
|
|
public function addActivity($data)
|
|
{
|
|
$taskData = array();
|
|
|
|
$actUid = parent::addActivity($data);
|
|
$taskData["TAS_UID"] = $actUid;
|
|
|
|
if (array_key_exists("ACT_NAME", $data)) {
|
|
$taskData["TAS_TITLE"] = $data["ACT_NAME"];
|
|
}
|
|
if (array_key_exists("ACT_NAME", $data)) {
|
|
$taskData["TAS_POSX"] = $data["BOU_X"];
|
|
}
|
|
if (array_key_exists("ACT_NAME", $data)) {
|
|
$taskData["TAS_POSY"] = $data["BOU_Y"];
|
|
}
|
|
if (array_key_exists("ACT_TYPE", $data)) {
|
|
if ($data["ACT_TYPE"] == "SUB_PROCESS") {
|
|
$taskData["TAS_TYPE"] = "SUBPROCESS";
|
|
} else {
|
|
$taskData["TAS_TYPE"] = "NORMAL";
|
|
}
|
|
}
|
|
|
|
$this->wp->addTask($taskData);
|
|
|
|
return $actUid;
|
|
}
|
|
|
|
public function updateActivity($actUid, $data)
|
|
{
|
|
parent::updateActivity($actUid, $data);
|
|
|
|
$taskData = array();
|
|
|
|
if (array_key_exists("ACT_NAME", $data)) {
|
|
$taskData["TAS_TITLE"] = $data["ACT_NAME"];
|
|
}
|
|
if (array_key_exists("ACT_NAME", $data)) {
|
|
$taskData["TAS_POSX"] = $data["BOU_X"];
|
|
}
|
|
if (array_key_exists("ACT_NAME", $data)) {
|
|
$taskData["TAS_POSY"] = $data["BOU_Y"];
|
|
}
|
|
|
|
$this->wp->updateTask($actUid, $taskData);
|
|
}
|
|
|
|
public function removeActivity($actUid)
|
|
{
|
|
parent::removeActivity($actUid);
|
|
$this->wp->removeTask($actUid);
|
|
|
|
}
|
|
|
|
public function removeGateway($gatUid)
|
|
{
|
|
// $gatewayData = $this->getGateway($gatUid);
|
|
// $flowsDest = \BpmnFlow::findAllBy(\BpmnFlowPeer::FLO_ELEMENT_DEST, $gatUid);
|
|
|
|
// foreach ($flowsDest as $flowDest) {
|
|
// switch ($flowDest->getFloElementOriginType()) {
|
|
// case "bpmnActivity":
|
|
// $actUid = $flowDest->getFloElementOrigin();
|
|
// $flowsOrigin = \BpmnFlow::findAllBy(\BpmnFlowPeer::FLO_ELEMENT_ORIGIN, $gatUid);
|
|
//
|
|
// foreach ($flowsOrigin as $flowOrigin) {
|
|
// switch ($flowOrigin->getFloElementDestType()) {
|
|
// case "bpmnActivity":
|
|
// $toActUid = $flowOrigin->getFloElementDest();
|
|
// $this->wp->removeRouteFromTo($actUid, $toActUid);
|
|
// break;
|
|
// }
|
|
// }
|
|
// break;
|
|
// }
|
|
// }
|
|
|
|
parent::removeGateway($gatUid);
|
|
}
|
|
|
|
public function addFlow($data)
|
|
{
|
|
$floUid = parent::addFlow($data);
|
|
|
|
// to add start event->activity as initial or end task
|
|
switch ($data["FLO_ELEMENT_ORIGIN_TYPE"]) {
|
|
case "bpmnEvent":
|
|
switch ($data["FLO_ELEMENT_DEST_TYPE"]) {
|
|
case "bpmnActivity":
|
|
$event = \BpmnEventPeer::retrieveByPK($data["FLO_ELEMENT_ORIGIN"]);
|
|
|
|
// setting as start task
|
|
if ($event && $event->getEvnType() == "START") {
|
|
$this->wp->setStartTask($data["FLO_ELEMENT_DEST"]);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case "bpmnActivity":
|
|
switch ($data["FLO_ELEMENT_DEST_TYPE"]) {
|
|
case "bpmnEvent":
|
|
$actUid = $data["FLO_ELEMENT_ORIGIN"];
|
|
$evnUid = $data["FLO_ELEMENT_DEST"];
|
|
$event = \BpmnEventPeer::retrieveByPK($evnUid);
|
|
|
|
// setting as end task
|
|
if ($event && $event->getEvnType() == "END") {
|
|
$this->wp->setEndTask($actUid);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return $floUid;
|
|
}
|
|
|
|
// public function updateFlow($floUid, $data, $flows)
|
|
// {
|
|
// parent::updateFlow($floUid, $data);
|
|
// }
|
|
|
|
public function removeFlow($floUid)
|
|
{
|
|
$flow = \BpmnFlowPeer::retrieveByPK($floUid);
|
|
parent::removeFlow($floUid);
|
|
|
|
// verify case: event(start) -> activity
|
|
// => find the corresponding task and unset it as start task
|
|
if ($flow->getFloElementOriginType() == "bpmnEvent" &&
|
|
$flow->getFloElementDestType() == "bpmnActivity"
|
|
) {
|
|
$event = \BpmnEventPeer::retrieveByPK($flow->getFloElementOrigin());
|
|
|
|
if (! is_null($event) && $event->getEvnType() == "START") {
|
|
$activity = \BpmnActivityPeer::retrieveByPK($flow->getFloElementDest());
|
|
if (! is_null($activity)) {
|
|
$this->wp->setStartTask($activity->getActUid(), false);
|
|
}
|
|
}
|
|
} elseif ($flow->getFloElementOriginType() == "bpmnActivity" &&
|
|
$flow->getFloElementDestType() == "bpmnEvent") {
|
|
// verify case: activity -> event(end)
|
|
// => find the corresponding task and unset it as start task
|
|
$event = \BpmnEventPeer::retrieveByPK($flow->getFloElementDest());
|
|
|
|
if (! is_null($event) && $event->getEvnType() == "END") {
|
|
$activity = \BpmnActivityPeer::retrieveByPK($flow->getFloElementOrigin());
|
|
|
|
if (! is_null($activity)) {
|
|
$this->wp->setEndTask($activity->getActUid(), false);
|
|
}
|
|
}
|
|
} else {
|
|
switch ($flow->getFloElementOriginType()) {
|
|
case "bpmnActivity":
|
|
switch ($flow->getFloElementDestType()) {
|
|
// activity->activity
|
|
case "bpmnActivity":
|
|
$this->wp->removeRouteFromTo($flow->getFloElementOrigin(), $flow->getFloElementDest());
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// TODO Complete for other routes, activity->activity, activity->gateway and viceversa
|
|
}
|
|
|
|
public function addEvent($data)
|
|
{
|
|
if (! array_key_exists("EVN_TYPE", $data)) {
|
|
throw new \RuntimeException("Required param \"EVN_TYPE\" is missing.");
|
|
}
|
|
|
|
return parent::addEvent($data);
|
|
}
|
|
|
|
public function mapBpmnFlowsToWorkflowRoutes()
|
|
{
|
|
$activities = $this->getActivities();
|
|
|
|
foreach ($activities as $activity) {
|
|
|
|
$flows = \BpmnFlow::findAllBy(array(
|
|
\BpmnFlowPeer::FLO_ELEMENT_ORIGIN => $activity["ACT_UID"],
|
|
\BpmnFlowPeer::FLO_ELEMENT_ORIGIN_TYPE => "bpmnActivity"
|
|
));
|
|
|
|
//
|
|
foreach ($flows as $flow) {
|
|
switch ($flow->getFloElementDestType()) {
|
|
case "bpmnActivity":
|
|
// (activity -> activity)
|
|
$this->wp->addRoute($activity["ACT_UID"], $flow->getFloElementDest(), "SEQUENTIAL");
|
|
break;
|
|
|
|
case "bpmnGateway":
|
|
// (activity -> gateway)
|
|
// we must find the related flows: gateway -> <object>
|
|
$gatUid = $flow->getFloElementDest();
|
|
$gatewayFlows = \BpmnFlow::findAllBy(array(
|
|
\BpmnFlowPeer::FLO_ELEMENT_ORIGIN => $gatUid,
|
|
\BpmnFlowPeer::FLO_ELEMENT_ORIGIN_TYPE => "bpmnGateway"
|
|
));
|
|
|
|
if ($gatewayFlows > 0) {
|
|
$this->wp->resetTaskRoutes($activity["ACT_UID"]);
|
|
}
|
|
|
|
foreach ($gatewayFlows as $gatewayFlow) {
|
|
$gatewayFlow = $gatewayFlow->toArray();
|
|
|
|
switch ($gatewayFlow['FLO_ELEMENT_DEST_TYPE']) {
|
|
case 'bpmnActivity':
|
|
// (gateway -> activity)
|
|
$gateway = \BpmnGateway::findOneBy(\BpmnGatewayPeer::GAT_UID, $gatUid)->toArray();
|
|
|
|
switch ($gateway["GAT_TYPE"]) {
|
|
//case 'SELECTION':
|
|
case self::BPMN_GATEWAY_COMPLEX:
|
|
$routeType = "SELECT";
|
|
break;
|
|
//case 'EVALUATION':
|
|
case self::BPMN_GATEWAY_EXCLUSIVE:
|
|
$routeType = "EVALUATE";
|
|
break;
|
|
//case 'PARALLEL':
|
|
case self::BPMN_GATEWAY_PARALLEL:
|
|
if ($gateway["GAT_DIRECTION"] == "DIVERGING") {
|
|
$routeType = "PARALLEL";
|
|
} elseif ($gateway["GAT_DIRECTION"] == "CONVERGING") {
|
|
$routeType = "SEC-JOIN";
|
|
} else {
|
|
throw new \LogicException(sprintf(
|
|
"Invalid Gateway direction, accepted values: [%s|%s], given: %s.",
|
|
"DIVERGING", "CONVERGING", $gateway["GAT_DIRECTION"]
|
|
));
|
|
}
|
|
break;
|
|
//case 'PARALLEL_EVALUATION':
|
|
case self::BPMN_GATEWAY_INCLUSIVE:
|
|
if ($gateway["GAT_DIRECTION"] == "DIVERGING") {
|
|
$routeType = "PARALLEL-BY-EVALUATION";
|
|
} elseif ($gateway["GAT_DIRECTION"] == "CONVERGING") {
|
|
$routeType = "SEC-JOIN";
|
|
} else {
|
|
throw new \LogicException(sprintf(
|
|
"Invalid Gateway direction, accepted values: [%s|%s], given: %s.",
|
|
"DIVERGING", "CONVERGING", $gateway["GAT_DIRECTION"]
|
|
));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
throw new \LogicException(sprintf("Unsupported Gateway type: %s", $gateway['GAT_TYPE']));
|
|
}
|
|
$condition = array_key_exists('FLO_CONDITION', $gatewayFlow) ? $gatewayFlow["FLO_CONDITION"] : '';
|
|
|
|
$this->wp->addRoute($activity["ACT_UID"], $gatewayFlow['FLO_ELEMENT_DEST'], $routeType, $condition);
|
|
break;
|
|
default:
|
|
// for processmaker is only allowed flows between "gateway -> activity"
|
|
// any another flow is considered invalid
|
|
throw new \LogicException(sprintf(
|
|
"For ProcessMaker is only allowed flows between \"gateway -> activity\" " . PHP_EOL .
|
|
"Given: bpmnGateway -> " . $gatewayFlow['FLO_ELEMENT_DEST_TYPE']
|
|
));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function remove()
|
|
{
|
|
parent::remove();
|
|
$this->wp->remove();
|
|
}
|
|
|
|
public static function createFromStruct($projectData)
|
|
{
|
|
$bwp = new self;
|
|
$result = array();
|
|
|
|
// if (array_key_exists("prj_uid", $projectData)) {
|
|
// $result[0]["old_uid"] = $projectData["prj_uid"];
|
|
// } else {
|
|
// $result[0]["old_uid"] = "";
|
|
// }
|
|
|
|
//$projectData["prj_uid"] = Util\Common::generateUID();
|
|
$result[0]["new_uid"] = $projectData["prj_uid"];
|
|
$result[0]["old_uid"] = "";
|
|
$result[0]["object"] = "project";
|
|
|
|
$bwp->create(array(
|
|
"PRJ_UID" => $projectData["prj_uid"],
|
|
"PRJ_AUTHOR" => $projectData["prj_author"]
|
|
));
|
|
$bwp->addDiagram(array_change_key_case($projectData["diagrams"][0], CASE_UPPER));
|
|
$bwp->addProcess(array_change_key_case($projectData["process"], CASE_UPPER));
|
|
|
|
$result = array_merge($result, self::updateFromStruct($bwp->prjUid, $projectData));
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Compose and return a Project struct
|
|
*
|
|
* Example struct return:
|
|
* array(
|
|
* "prj_uid" => "25111170353317e324d6e23073851309",
|
|
* "prj_name" => "example project",
|
|
* "prj_description" => "project desc.",
|
|
* ...
|
|
* "diagrams" => array(
|
|
* array(
|
|
* "dia_uid" => "94208559153317e325f1c24068030751",
|
|
* "dia_name" => "Example Diagram",
|
|
* ...
|
|
* "activities" => array(...),
|
|
* "events" => array(...),
|
|
* "gateways" => array(...),
|
|
* "flows" => array(...),
|
|
* "artifacts" => array(...),
|
|
* "laneset" => array(...),
|
|
* "lanes" => array(...)
|
|
* )
|
|
* )
|
|
* )
|
|
*
|
|
* @param $prjUid
|
|
* @return array
|
|
*/
|
|
public static function getStruct($prjUid)
|
|
{
|
|
$bwp = BpmnWorkflow::load($prjUid);
|
|
|
|
$project = array_change_key_case($bwp->getProject(), CASE_LOWER);
|
|
$diagram = $bwp->getDiagram();
|
|
$process = $bwp->getProcess();
|
|
$diagram["pro_uid"] = $process["PRO_UID"];
|
|
|
|
$configList = array("changeCaseTo" => CASE_LOWER);
|
|
|
|
if (! is_null($diagram)) {
|
|
$diagram = array_change_key_case($diagram, CASE_LOWER);
|
|
$diagram["activities"] = $bwp->getActivities($configList);
|
|
$diagram["events"] = $bwp->getEvents($configList);
|
|
$diagram["gateways"] = $bwp->getGateways($configList);
|
|
$diagram["flows"] = $bwp->getFlows($configList);
|
|
$diagram["artifacts"] = $bwp->getArtifacts($configList);
|
|
$diagram["laneset"] = $bwp->getLanesets($configList);
|
|
$diagram["lanes"] = $bwp->getLanes($configList);
|
|
$project["diagrams"][] = $diagram;
|
|
}
|
|
|
|
return $project;
|
|
}
|
|
|
|
/**
|
|
* Update project from a struct defined.
|
|
*
|
|
* This function make add, update or delete of elements of a project
|
|
* Actions is based on a diff from project save in Db and the given structure as param, by the following criteria.
|
|
*
|
|
* 1. Elements that are on the struct, but they are not in the Db will be created on Db
|
|
* 2. Elements that are on the struct and they are found in db, will be compared, if they have been modified then will be updated on Db
|
|
* 3. Elements found in Db but they are not present on the struct will be considered deleted, so they will be deleted from Db.
|
|
*
|
|
* Example Struct:
|
|
* array(
|
|
* "prj_uid" => "25111170353317e324d6e23073851309",
|
|
* "prj_name" => "example project",
|
|
* "prj_description" => "project desc.",
|
|
* ...
|
|
* "diagrams" => array(
|
|
* array(
|
|
* "dia_uid" => "94208559153317e325f1c24068030751",
|
|
* "dia_name" => "Example Diagram",
|
|
* ...
|
|
* "activities" => array(...),
|
|
* "events" => array(...),
|
|
* "gateways" => array(...),
|
|
* "flows" => array(...),
|
|
* "artifacts" => array(...),
|
|
* "laneset" => array(...),
|
|
* "lanes" => array(...)
|
|
* )
|
|
* )
|
|
* )
|
|
*
|
|
* Notes:
|
|
* 1. All elements keys are in lowercase
|
|
* 2. the "diagrams" element is an array of arrays
|
|
*
|
|
* @param $prjUid
|
|
* @param $projectData
|
|
* @return array
|
|
*/
|
|
public static function updateFromStruct($prjUid, $projectData)
|
|
{
|
|
$diagram = isset($projectData["diagrams"]) && isset($projectData["diagrams"][0]) ? $projectData["diagrams"][0] : array();
|
|
$result = array();
|
|
$bwp = BpmnWorkflow::load($prjUid);
|
|
//var_dump($bwp->getUid()); die;
|
|
|
|
/*
|
|
* Diagram's Activities Handling
|
|
*/
|
|
$whiteList = array();
|
|
foreach ($diagram["activities"] as $i => $activityData) {
|
|
$activityData = array_change_key_case($activityData, CASE_UPPER);
|
|
unset($activityData["_EXTENDED"], $activityData["BOU_ELEMENT_ID"]);
|
|
$activityData = Util\ArrayUtil::boolToIntValues($activityData);
|
|
|
|
$activity = $bwp->getActivity($activityData["ACT_UID"]);
|
|
if (is_null($activity)) {
|
|
$oldActUid = $activityData["ACT_UID"];
|
|
$activityData["ACT_UID"] = Util\Common::generateUID();
|
|
$bwp->addActivity($activityData);
|
|
$result[] = array("object" => "activity", "new_uid" => $activityData["ACT_UID"], "old_uid" => $oldActUid);
|
|
} elseif (! $bwp->isEquals($activity, $activityData)) {
|
|
$bwp->updateActivity($activityData["ACT_UID"], $activityData);
|
|
} else {
|
|
Util\Logger::log("Update Activity ({$activityData["ACT_UID"]}) Skipped - No changes required");
|
|
}
|
|
|
|
$diagram["activities"][$i] = $activityData;
|
|
$whiteList[] = $activityData["ACT_UID"];
|
|
}
|
|
|
|
$activities = $bwp->getActivities();
|
|
|
|
// looking for removed elements
|
|
foreach ($activities as $activityData) {
|
|
if (! in_array($activityData["ACT_UID"], $whiteList)) {
|
|
$bwp->removeActivity($activityData["ACT_UID"]);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Diagram's Gateways Handling
|
|
*/
|
|
$whiteList = array();
|
|
//print_r($diagram);
|
|
foreach ($diagram["gateways"] as $i => $gatewayData) {
|
|
$gatewayData = array_change_key_case($gatewayData, CASE_UPPER);
|
|
unset($gatewayData["_EXTENDED"]);
|
|
|
|
$gateway = $bwp->getGateway($gatewayData["GAT_UID"]);
|
|
if (is_null($gateway)) {
|
|
$oldActUid = $gatewayData["GAT_UID"];
|
|
$gatewayData["GAT_UID"] = Util\Common::generateUID();
|
|
$bwp->addGateway($gatewayData);
|
|
$result[] = array("object" => "gateway", "new_uid" => $gatewayData["GAT_UID"], "old_uid" => $oldActUid);
|
|
} elseif (! $bwp->isEquals($gateway, $gatewayData)) {
|
|
$bwp->updateGateway($gatewayData["GAT_UID"], $gatewayData);
|
|
} else {
|
|
Util\Logger::log("Update Gateway ({$gatewayData["GAT_UID"]}) Skipped - No changes required");
|
|
}
|
|
|
|
$diagram["gateways"][$i] = $gatewayData;
|
|
$whiteList[] = $gatewayData["GAT_UID"];
|
|
}
|
|
|
|
$gateways = $bwp->getGateways();
|
|
|
|
// looking for removed elements
|
|
foreach ($gateways as $gatewayData) {
|
|
if (! in_array($gatewayData["GAT_UID"], $whiteList)) {
|
|
$bwp->removeGateway($gatewayData["GAT_UID"]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Diagram's Events Handling
|
|
*/
|
|
$whiteList = array();
|
|
foreach ($diagram["events"] as $i => $eventData) {
|
|
$eventData = array_change_key_case($eventData, CASE_UPPER);
|
|
unset($eventData["_EXTENDED"]);
|
|
if (array_key_exists("EVN_CANCEL_ACTIVITY", $eventData)) {
|
|
$eventData["EVN_CANCEL_ACTIVITY"] = $eventData["EVN_CANCEL_ACTIVITY"] ? 1 : 0;
|
|
}
|
|
if (array_key_exists("EVN_WAIT_FOR_COMPLETION", $eventData)) {
|
|
$eventData["EVN_WAIT_FOR_COMPLETION"] = $eventData["EVN_WAIT_FOR_COMPLETION"] ? 1 : 0;
|
|
}
|
|
|
|
$event = $bwp->getEvent($eventData["EVN_UID"]);
|
|
if (is_null($event)) {
|
|
$oldActUid = $eventData["EVN_UID"];
|
|
$eventData["EVN_UID"] = Util\Common::generateUID();
|
|
$bwp->addEvent($eventData);
|
|
$result[] = array("object" => "event", "new_uid" => $eventData["EVN_UID"], "old_uid" => $oldActUid);
|
|
} elseif (! $bwp->isEquals($event, $eventData)) {
|
|
$bwp->updateEvent($eventData["EVN_UID"], $eventData);
|
|
} else {
|
|
Util\Logger::log("Update Event ({$eventData["EVN_UID"]}) Skipped - No changes required");
|
|
}
|
|
|
|
$diagram["events"][$i] = $eventData;
|
|
$whiteList[] = $eventData["EVN_UID"];
|
|
}
|
|
|
|
$events = $bwp->getEvents();
|
|
|
|
// looking for removed elements
|
|
foreach ($events as $eventData) {
|
|
if (! in_array($eventData["EVN_UID"], $whiteList)) {
|
|
// If it is not in the white list so, then remove them
|
|
$bwp->removeEvent($eventData["EVN_UID"]);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Diagram's Flows Handling
|
|
*/
|
|
$whiteList = array();
|
|
|
|
foreach ($diagram["flows"] as $i => $flowData) {
|
|
$flowData = array_change_key_case($flowData, CASE_UPPER);
|
|
|
|
// if it is a new flow record
|
|
if (! \BpmnFlow::exists($flowData["FLO_UID"])) {
|
|
$oldFloUid = $flowData["FLO_UID"];
|
|
$flowData["FLO_UID"] = Util\Common::generateUID();
|
|
|
|
$mappedUid = self::mapUid($flowData["FLO_ELEMENT_ORIGIN"], $result);
|
|
if ($mappedUid !== false) {
|
|
$flowData["FLO_ELEMENT_ORIGIN"] = $mappedUid;
|
|
}
|
|
|
|
$mappedUid = self::mapUid($flowData["FLO_ELEMENT_DEST"], $result);
|
|
if ($mappedUid !== false) {
|
|
$flowData["FLO_ELEMENT_DEST"] = $mappedUid;
|
|
}
|
|
|
|
$result[] = array("object" => "flow", "new_uid" => $flowData["FLO_UID"], "old_uid" => $oldFloUid);
|
|
}
|
|
|
|
$diagram["flows"][$i] = $flowData;
|
|
$whiteList[] = $flowData["FLO_UID"];
|
|
}
|
|
|
|
foreach ($diagram["flows"] as $flowData) {
|
|
$flow = $bwp->getFlow($flowData["FLO_UID"]);
|
|
if (is_null($flow)) {
|
|
$bwp->addFlow($flowData, $diagram["flows"]);
|
|
} elseif (! $bwp->isEquals($flow, $flowData)) {
|
|
$bwp->updateFlow($flowData["FLO_UID"], $flowData, $diagram["flows"]);
|
|
} else {
|
|
Util\Logger::log("Update Flow ({$flowData["FLO_UID"]}) Skipped - No changes required");
|
|
}
|
|
}
|
|
|
|
$flows = $bwp->getFlows();
|
|
|
|
// looking for removed elements
|
|
foreach ($flows as $flowData) {
|
|
if (! in_array($flowData["FLO_UID"], $whiteList)) {
|
|
$bwp->removeFlow($flowData["FLO_UID"]);
|
|
}
|
|
}
|
|
|
|
$bwp->mapBpmnFlowsToWorkflowRoutes();
|
|
|
|
return $result;
|
|
}
|
|
|
|
protected static function mapUid($oldUid, $list)
|
|
{
|
|
foreach ($list as $item) {
|
|
if ($item["old_uid"] == $oldUid) {
|
|
return $item["new_uid"];
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|