/**
  * If this collection has already been initialized with
  * an identical criteria, it returns the collection.
  * Otherwise if this BpmnProject is new, it will return
  * an empty collection; or if this BpmnProject has previously
  * been saved, it will retrieve related BpmnActivitys from storage.
  *
  * This method is protected by default in order to keep the public
  * api reasonable.  You can provide public methods for those you
  * actually need in BpmnProject.
  */
 public function getBpmnActivitysJoinBpmnProcess($criteria = null, $con = null)
 {
     // include the Peer class
     include_once 'classes/model/om/BaseBpmnActivityPeer.php';
     if ($criteria === null) {
         $criteria = new Criteria();
     } elseif ($criteria instanceof Criteria) {
         $criteria = clone $criteria;
     }
     if ($this->collBpmnActivitys === null) {
         if ($this->isNew()) {
             $this->collBpmnActivitys = array();
         } else {
             $criteria->add(BpmnActivityPeer::PRJ_UID, $this->getPrjUid());
             $this->collBpmnActivitys = BpmnActivityPeer::doSelectJoinBpmnProcess($criteria, $con);
         }
     } else {
         // the following code is to determine if a new query is
         // called for.  If the criteria is the same as the last
         // one, just return the collection.
         $criteria->add(BpmnActivityPeer::PRJ_UID, $this->getPrjUid());
         if (!isset($this->lastBpmnActivityCriteria) || !$this->lastBpmnActivityCriteria->equals($criteria)) {
             $this->collBpmnActivitys = BpmnActivityPeer::doSelectJoinBpmnProcess($criteria, $con);
         }
     }
     $this->lastBpmnActivityCriteria = $criteria;
     return $this->collBpmnActivitys;
 }
Example #2
0
 /**
  * Update properties of an Task
  * @var string $prj_uid. Uid for Process
  * @var string $act_uid. Uid for Activity
  * @var array $arrayProperty. Data for properties of Activity
  *
  * @author Brayan Pereyra (Cochalo) <*****@*****.**>
  * @copyright Colosa - Bolivia
  *
  * return object
  */
 public function updateProperties($prj_uid, $act_uid, $arrayProperty)
 {
     //Copy of processmaker/workflow/engine/methods/tasks/tasks_Ajax.php //case "saveTaskData":
     try {
         if (isset($arrayProperty['properties'])) {
             $arrayProperty = array_change_key_case($arrayProperty['properties'], CASE_UPPER);
         }
         $prj_uid = $this->validateProUid($prj_uid);
         $act_uid = $this->validateActUid($act_uid);
         $arrayProperty["TAS_UID"] = $act_uid;
         $arrayProperty["PRO_UID"] = $prj_uid;
         $task = new \Task();
         $aTaskInfo = $task->load($arrayProperty["TAS_UID"]);
         $bpmnActivity = \BpmnActivityPeer::retrieveByPK($act_uid);
         $arrayResult = array();
         if ($arrayProperty["TAS_SELFSERVICE_TIMEOUT"] == "1") {
             if (!is_numeric($arrayProperty["TAS_SELFSERVICE_TIME"]) || $arrayProperty["TAS_SELFSERVICE_TIME"] == '') {
                 throw new \Exception("Invalid value specified for 'tas_selfservice_time'");
             }
         }
         foreach ($arrayProperty as $k => $v) {
             $arrayProperty[$k] = str_replace("@amp@", "&", $v);
         }
         if (isset($arrayProperty["TAS_SEND_LAST_EMAIL"])) {
             $arrayProperty["TAS_SEND_LAST_EMAIL"] = $arrayProperty["TAS_SEND_LAST_EMAIL"] == "TRUE" ? "TRUE" : "FALSE";
         } else {
             if (isset($arrayProperty["SEND_EMAIL"])) {
                 $arrayProperty["TAS_SEND_LAST_EMAIL"] = $arrayProperty["SEND_EMAIL"] == "TRUE" ? "TRUE" : "FALSE";
             } else {
                 $arrayProperty["TAS_SEND_LAST_EMAIL"] = is_null($aTaskInfo["TAS_SEND_LAST_EMAIL"]) ? "FALSE" : $aTaskInfo["TAS_SEND_LAST_EMAIL"];
             }
         }
         //Validating TAS_ASSIGN_VARIABLE value
         if (!isset($arrayProperty["TAS_ASSIGN_TYPE"])) {
             $derivateType = $task->kgetassigType($arrayProperty["PRO_UID"], $arrayProperty["TAS_UID"]);
             if (is_null($derivateType)) {
                 $arrayProperty["TAS_ASSIGN_TYPE"] = "BALANCED";
             } else {
                 $arrayProperty["TAS_ASSIGN_TYPE"] = $derivateType["TAS_ASSIGN_TYPE"];
             }
         }
         $flagTaskIsMultipleInstance = $bpmnActivity->getActType() == "TASK" && preg_match("/^(?:EMPTY|USERTASK|MANUALTASK)\$/", $bpmnActivity->getActTaskType()) && $bpmnActivity->getActLoopType() == "PARALLEL";
         $flagTaskAssignTypeIsMultipleInstance = preg_match("/^(?:MULTIPLE_INSTANCE|MULTIPLE_INSTANCE_VALUE_BASED)\$/", $arrayProperty["TAS_ASSIGN_TYPE"]);
         if ($flagTaskIsMultipleInstance && !$flagTaskAssignTypeIsMultipleInstance) {
             $arrayProperty["TAS_ASSIGN_TYPE"] = "MULTIPLE_INSTANCE";
             $flagTaskAssignTypeIsMultipleInstance = true;
         }
         if ($flagTaskIsMultipleInstance && !$flagTaskAssignTypeIsMultipleInstance) {
             throw new \Exception(\G::LoadTranslation("ID_ACTIVITY_INVALID_ASSIGNMENT_METHOD_FOR_MULTIPLE_INSTANCE_ACTIVITY", array(strtolower("ACT_UID"), $act_uid)));
         }
         if (!$flagTaskIsMultipleInstance && $flagTaskAssignTypeIsMultipleInstance) {
             $arrayProperty["TAS_ASSIGN_TYPE"] = "BALANCED";
             $flagTaskAssignTypeIsMultipleInstance = false;
         }
         if (!$flagTaskIsMultipleInstance && $flagTaskAssignTypeIsMultipleInstance) {
             throw new \Exception(\G::LoadTranslation("ID_ACTIVITY_INVALID_ASSIGNMENT_METHOD_FOR_ACTIVITY", array(strtolower("ACT_UID"), $act_uid)));
         }
         switch ($arrayProperty["TAS_ASSIGN_TYPE"]) {
             case 'BALANCED':
             case 'MANUAL':
             case 'REPORT_TO':
                 $this->unsetVar($arrayProperty, "TAS_ASSIGN_VARIABLE");
                 $this->unsetVar($arrayProperty, "TAS_GROUP_VARIABLE");
                 $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TIMEOUT");
                 $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TIME");
                 $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TIME_UNIT");
                 $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TRIGGER_UID");
                 $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_EXECUTION");
                 break;
             case 'EVALUATE':
                 if (empty($arrayProperty["TAS_ASSIGN_VARIABLE"])) {
                     throw new \Exception("Invalid value specified for 'tas_assign_variable'");
                 }
                 $this->unsetVar($arrayProperty, "TAS_GROUP_VARIABLE");
                 $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TIMEOUT");
                 $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TIME");
                 $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TIME_UNIT");
                 $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TRIGGER_UID");
                 $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_EXECUTION");
                 break;
             case 'SELF_SERVICE':
             case 'SELF_SERVICE_EVALUATE':
                 if ($arrayProperty["TAS_ASSIGN_TYPE"] == "SELF_SERVICE_EVALUATE") {
                     if (empty($arrayProperty["TAS_GROUP_VARIABLE"])) {
                         throw new \Exception("Invalid value specified for 'tas_group_variable'");
                     }
                 } else {
                     $arrayProperty["TAS_GROUP_VARIABLE"] = '';
                 }
                 $arrayProperty["TAS_ASSIGN_TYPE"] = "SELF_SERVICE";
                 if (!($arrayProperty["TAS_SELFSERVICE_TIMEOUT"] == 0 || $arrayProperty["TAS_SELFSERVICE_TIMEOUT"] == 1)) {
                     throw new \Exception("Invalid value specified for 'tas_selfservice_timeout'");
                 }
                 if ($arrayProperty["TAS_SELFSERVICE_TIMEOUT"] == "1") {
                     if (empty($arrayProperty["TAS_SELFSERVICE_TIME"])) {
                         throw new \Exception("Invalid value specified for 'tas_assign_variable'");
                     }
                     if (empty($arrayProperty["TAS_SELFSERVICE_TIME_UNIT"])) {
                         throw new \Exception("Invalid value specified for 'tas_selfservice_time_unit'");
                     }
                     if (empty($arrayProperty["TAS_SELFSERVICE_TRIGGER_UID"])) {
                         throw new \Exception("Invalid value specified for 'tas_selfservice_trigger_uid'");
                     }
                     if (empty($arrayProperty["TAS_SELFSERVICE_EXECUTION"])) {
                         throw new \Exception("Invalid value specified for 'tas_selfservice_execution'");
                     }
                 } else {
                     $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TIME");
                     $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TIME_UNIT");
                     $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_TRIGGER_UID");
                     $this->unsetVar($arrayProperty, "TAS_SELFSERVICE_EXECUTION");
                 }
                 break;
             case "MULTIPLE_INSTANCE_VALUE_BASED":
                 if (trim($arrayProperty["TAS_ASSIGN_VARIABLE"]) == "") {
                     throw new \Exception(\G::LoadTranslation("ID_INVALID_VALUE_CAN_NOT_BE_EMPTY", array(strtolower("TAS_ASSIGN_VARIABLE"))));
                 }
                 break;
         }
         //Validating TAS_TRANSFER_FLY value
         if ($arrayProperty["TAS_TRANSFER_FLY"] == "FALSE") {
             if (!isset($arrayProperty["TAS_DURATION"])) {
                 throw new \Exception("Invalid value specified for 'tas_duration'");
             }
             $valuesTimeUnit = array('DAYS', 'HOURS', 'MINUTES');
             if (!isset($arrayProperty["TAS_TIMEUNIT"]) || !in_array($arrayProperty["TAS_TIMEUNIT"], $valuesTimeUnit)) {
                 throw new \Exception("Invalid value specified for 'tas_timeunit'");
             }
             $valuesTypeDay = array('1', '2', '');
             if (!isset($arrayProperty["TAS_TYPE_DAY"]) || !in_array($arrayProperty["TAS_TYPE_DAY"], $valuesTypeDay)) {
                 throw new \Exception("Invalid value specified for 'tas_type_day'");
             }
             if (!isset($arrayProperty["TAS_CALENDAR"])) {
                 throw new \Exception("Invalid value specified for 'tas_calendar'");
             }
         } else {
             $this->unsetVar($arrayProperty, "TAS_DURATION");
             $this->unsetVar($arrayProperty, "TAS_TIMEUNIT");
             $this->unsetVar($arrayProperty, "TAS_TYPE_DAY");
             $this->unsetVar($arrayProperty, "TAS_CALENDAR");
         }
         if ($arrayProperty["TAS_SEND_LAST_EMAIL"] == "TRUE") {
             if (empty($arrayProperty["TAS_DEF_SUBJECT_MESSAGE"])) {
                 throw new \Exception("Invalid value specified for 'tas_def_subject_message'");
             }
             $valuesDefMessageType = array('template', 'text');
             if (!isset($arrayProperty["TAS_DEF_MESSAGE_TYPE"]) || !in_array($arrayProperty["TAS_DEF_MESSAGE_TYPE"], $valuesDefMessageType)) {
                 throw new \Exception("Invalid value specified for 'tas_def_message_type'");
             }
             if ($arrayProperty["TAS_DEF_MESSAGE_TYPE"] == 'template') {
                 if (empty($arrayProperty["TAS_DEF_MESSAGE_TEMPLATE"])) {
                     throw new \Exception("Invalid value specified for 'tas_def_message_template'");
                 }
                 $this->unsetVar($arrayProperty, "TAS_DEF_MESSAGE");
             } else {
                 if (empty($arrayProperty["TAS_DEF_MESSAGE"])) {
                     throw new \Exception("Invalid value specified for 'tas_def_message'");
                 }
                 $this->unsetVar($arrayProperty, "TAS_DEF_MESSAGE_TEMPLATE");
             }
             //Additional configuration
             if (isset($arrayProperty["TAS_DEF_MESSAGE_TYPE"])) {
                 \G::LoadClass("configuration");
                 $oConf = new \Configurations();
                 if (!isset($arrayProperty["TAS_DEF_MESSAGE_TEMPLATE"])) {
                     $arrayProperty["TAS_DEF_MESSAGE_TEMPLATE"] = "alert_message.html";
                 }
                 $oConf->aConfig = array("TAS_DEF_MESSAGE_TYPE" => $arrayProperty["TAS_DEF_MESSAGE_TYPE"], "TAS_DEF_MESSAGE_TEMPLATE" => $arrayProperty["TAS_DEF_MESSAGE_TEMPLATE"]);
                 $oConf->saveConfig("TAS_EXTRA_PROPERTIES", $arrayProperty["TAS_UID"], "", "");
             }
         } else {
             $this->unsetVar($arrayProperty, "TAS_DEF_SUBJECT_MESSAGE");
             $this->unsetVar($arrayProperty, "TAS_DEF_MESSAGE_TYPE");
             $this->unsetVar($arrayProperty, "TAS_DEF_MESSAGE");
             $this->unsetVar($arrayProperty, "TAS_DEF_MESSAGE_TEMPLATE");
         }
         $result = $task->update($arrayProperty);
         if (!empty($arrayProperty['CONSOLIDATE_DATA'])) {
             if (!empty($arrayProperty['CONSOLIDATE_DATA']['consolidated_dynaform'])) {
                 G::LoadClass("consolidatedCases");
                 $consolidated = new \ConsolidatedCases();
                 $dataConso = array('con_status' => $arrayProperty['CONSOLIDATE_DATA']['consolidated_enable'], 'tas_uid' => $arrayProperty['TAS_UID'], 'dyn_uid' => $arrayProperty['CONSOLIDATE_DATA']['consolidated_dynaform'], 'pro_uid' => $arrayProperty['PRO_UID'], 'rep_uid' => $arrayProperty['CONSOLIDATE_DATA']['consolidated_report_table'], 'table_name' => $arrayProperty['CONSOLIDATE_DATA']['consolidated_table'], 'title' => $arrayProperty['CONSOLIDATE_DATA']['consolidated_title']);
                 $consolidated->saveConsolidated($dataConso);
             }
         }
         $arrayResult["status"] = "OK";
         if ($result == 3) {
             $arrayResult["status"] = "CRONCL";
         }
         return $arrayResult;
     } catch (Exception $e) {
         throw $e;
     }
 }
Example #3
0
 /**
  * Get data of a Script-Task by unique id of Activity
  *
  * @param string $projectUid  Unique id of Project
  * @param string $activityUid Unique id of Event
  *
  * return array Return an array with data of a Script-Task by unique id of Activity
  */
 public function getScriptTaskByActivity($projectUid, $activityUid)
 {
     try {
         //Verify data
         $process = new \ProcessMaker\BusinessModel\Process();
         $process->throwExceptionIfNotExistsProcess($projectUid, $this->arrayFieldNameForException["projectUid"]);
         //---
         $obj = \BpmnActivityPeer::retrieveByPK($activityUid);
         if (is_null($obj)) {
             throw new \Exception(\G::LoadTranslation("ID_SCRIPT_TASK_DOES_NOT_ACTIVITY", array($this->arrayFieldNameForException["actUid"], $activityUid)));
         }
         //---
         $criteria = new \Criteria("workflow");
         $criteria->addSelectColumn(\BpmnActivityPeer::ACT_UID);
         $criteria->add(\BpmnActivityPeer::PRJ_UID, $projectUid, \Criteria::EQUAL);
         $criteria->add(\BpmnActivityPeer::ACT_UID, $activityUid, \Criteria::EQUAL);
         $rsCriteria = \BpmnActivityPeer::doSelectRS($criteria);
         $rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
         if (!$rsCriteria->next()) {
             throw new \Exception(\G::LoadTranslation("ID_SCRIPT_TASK_ACTIVITY_NOT_BELONG_TO_PROJECT", array($arrayData["ACT_UID"], $projectUid)));
         }
         //---
         $criteria = $this->getScriptTaskCriteria();
         $criteria->add(\ScriptTaskPeer::PRJ_UID, $projectUid, \Criteria::EQUAL);
         $criteria->add(\ScriptTaskPeer::ACT_UID, $activityUid, \Criteria::EQUAL);
         $rsCriteria = \ScriptTaskPeer::doSelectRS($criteria);
         $rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
         //Return
         return $rsCriteria->next() ? $this->getScriptTaskDataFromRecord($rsCriteria->getRow()) : array();
     } catch (\Exception $e) {
         throw $e;
     }
 }
Example #4
0
    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"
        ) {
            $bpmnFlow = \BpmnFlow::findOneBy(array(
                \BpmnFlowPeer::FLO_ELEMENT_ORIGIN      => $flow->getFloElementOrigin(),
                \BpmnFlowPeer::FLO_ELEMENT_ORIGIN_TYPE => "bpmnEvent",
                \BpmnFlowPeer::FLO_ELEMENT_DEST        => $flow->getFloElementDest(),
                \BpmnFlowPeer::FLO_ELEMENT_DEST_TYPE   => "bpmnActivity"
            ));

            if (is_null($bpmnFlow)) {
                $event = \BpmnEventPeer::retrieveByPK($flow->getFloElementOrigin());

                if (!is_null($event) && $event->getEvnType() == "START" && $event->getEvnMarker() == "EMPTY") {
                    $activity = \BpmnActivityPeer::retrieveByPK($flow->getFloElementDest());

                    //Remove as start Task
                    if (!is_null($activity)) {
                        $this->wp->setStartTask($activity->getActUid(), false);
                    }
                }
            }

            //$this->updateEventStartObjects($flow->getFloElementOrigin(), "");

            //WebEntry-Event - Update
            if (is_null($bpmnFlow)) {
                $this->updateWebEntryEventByEvent($flow->getFloElementOrigin(), array("WEE_STATUS" => "DISABLED"));
            }
        } 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" && $event->getEvnMarker() == "EMPTY") {
                $activity = \BpmnActivityPeer::retrieveByPK($flow->getFloElementOrigin());

                //Remove as end Task
                if (! is_null($activity)) {
                    $this->wp->setEndTask($activity->getActUid(), false);
                }
            }
        } else {
            switch ($flow->getFloElementOriginType()) {
                case "bpmnActivity":
                    switch ($flow->getFloElementDestType()) {
                        //Activity1 -> Activity2
                        case "bpmnActivity":
                            $this->wp->removeRouteFromTo($flow->getFloElementOrigin(), $flow->getFloElementDest());
                            break;
                    }
                    break;
                case "bpmnEvent":
                    switch ($flow->getFloElementDestType()) {
                        //Event1 -> Event2
                        case "bpmnEvent":
                            if ($flow->getFloType() == "MESSAGE") {
                                //Delete Message-Event-Relation
                                $messageEventRelation = new \ProcessMaker\BusinessModel\MessageEventRelation();

                                $messageEventRelation->deleteWhere(array(
                                    \MessageEventRelationPeer::PRJ_UID       => $flow->getPrjUid(),
                                    \MessageEventRelationPeer::EVN_UID_THROW => $flow->getFloElementOrigin(),
                                    \MessageEventRelationPeer::EVN_UID_CATCH => $flow->getFloElementDest()
                                ));
                            }
                            break;
                    }
                    break;
            }
        }

        // TODO Complete for other routes, activity->activity, activity->gateway and viceversa
    }
Example #5
0
    public function removeActivity($actUid)
    {
        try {
            self::log("Remove Activity: $actUid");

            $activity = ActivityPeer::retrieveByPK($actUid);
            $activity->delete();
            //TODO if the activity was removed, the related flows to that activity must be removed

            self::log("Remove Activity Success!");
        } catch (\Exception $e) {
            self::log("Exception: ", $e->getMessage(), "Trace: ", $e->getTraceAsString());
            throw $e;
        }
    }
Example #6
0
 public static function exists($actUid)
 {
     $c = new Criteria("workflow");
     $c->add(BpmnActivityPeer::ACT_UID, $actUid);
     return BpmnActivityPeer::doCount($c) > 0 ? true : false;
 }
 /**
  * Retrieve multiple objects by pkey.
  *
  * @param      array $pks List of primary keys
  * @param      Connection $con the connection to use
  * @throws     PropelException Any exceptions caught during processing will be
  *       rethrown wrapped into a PropelException.
  */
 public static function retrieveByPKs($pks, $con = null)
 {
     if ($con === null) {
         $con = Propel::getConnection(self::DATABASE_NAME);
     }
     $objs = null;
     if (empty($pks)) {
         $objs = array();
     } else {
         $criteria = new Criteria();
         $criteria->add(BpmnActivityPeer::ACT_UID, $pks, Criteria::IN);
         $objs = BpmnActivityPeer::doSelect($criteria, $con);
     }
     return $objs;
 }
    function derivate($currentDelegation = array(), $nextDelegations = array(), $removeList = true)

    {

        //define this...

        if (! defined( 'TASK_FINISH_PROCESS' )) {

            define( 'TASK_FINISH_PROCESS', - 1 );

        }

        if (! defined( 'TASK_FINISH_TASK' )) {

            define( 'TASK_FINISH_TASK', - 2 );

        }



        $this->case = new cases();



        //Get data for this DEL_INDEX current

        $appFields = $this->case->loadCase( $currentDelegation['APP_UID'], $currentDelegation['DEL_INDEX'] );



        //We close the current derivation, then we'll try to derivate to each defined route

        $this->case->CloseCurrentDelegation( $currentDelegation['APP_UID'], $currentDelegation['DEL_INDEX'] );



        //Get data for current delegation (current Task)

        $task = TaskPeer::retrieveByPK($currentDelegation["TAS_UID"]);

        $bpmnActivity = BpmnActivityPeer::retrieveByPK($currentDelegation["TAS_UID"]);



        $flagTaskIsMultipleInstance = false;

        $flagTaskAssignTypeIsMultipleInstance = false;



        if (!is_null($task) && !is_null($bpmnActivity)) {

            $flagTaskIsMultipleInstance = $bpmnActivity->getActType() == "TASK" && preg_match("/^(?:EMPTY|USERTASK|MANUALTASK)$/", $bpmnActivity->getActTaskType()) && $bpmnActivity->getActLoopType() == "PARALLEL";

            $flagTaskAssignTypeIsMultipleInstance = preg_match("/^(?:MULTIPLE_INSTANCE|MULTIPLE_INSTANCE_VALUE_BASED)$/", $task->getTasAssignType());

        }



        $currentDelegation["TAS_ASSIGN_TYPE"] = $task->getTasAssignType();

        $currentDelegation["TAS_MI_COMPLETE_VARIABLE"] = $task->getTasMiCompleteVariable();

        $currentDelegation["TAS_MI_INSTANCE_VARIABLE"] = $task->getTasMiInstanceVariable();



        //Count how many tasks should be derivated.

        //$countNextTask = count($nextDelegations);

        //$removeList = true;



        foreach ($nextDelegations as $nextDel) {

            //BpmnEvent - END-MESSAGE-EVENT, END-EMAIL-EVENT

            //Check and get unique id

            if (preg_match("/^(.{32})\/(\-1)$/", $nextDel["TAS_UID"], $arrayMatch)) {

                $nextDel["TAS_UID"] = $arrayMatch[2];

                $nextDel["TAS_UID_DUMMY"] = $arrayMatch[1];

            }



            //subprocesses??

            if ($nextDel['TAS_PARENT'] != '') {

                $oCriteria = new Criteria( 'workflow' );

                $oCriteria->add( SubProcessPeer::PRO_PARENT, $appFields['PRO_UID'] );

                $oCriteria->add( SubProcessPeer::TAS_PARENT, $nextDel['TAS_PARENT'] );

                if (SubProcessPeer::doCount( $oCriteria ) > 0) {

                    $oDataset = SubProcessPeer::doSelectRS( $oCriteria );

                    $oDataset->setFetchmode( ResultSet::FETCHMODE_ASSOC );

                    $oDataset->next();

                    $aSP = $oDataset->getRow();

                    $aSP['USR_UID'] = $nextDel['USR_UID'];

                    $oTask = new Task();

                    $aTask = $oTask->load( $nextDel['TAS_PARENT'] );

                    $nextDel = array ('TAS_UID' => $aTask['TAS_UID'],'USR_UID' => $aSP['USR_UID'],'TAS_ASSIGN_TYPE' => $aTask['TAS_ASSIGN_TYPE'],'TAS_DEF_PROC_CODE' => $aTask['TAS_DEF_PROC_CODE'],'DEL_PRIORITY' => 3,'TAS_PARENT' => ''

                    );

                } else {

                    continue;

                }

            }



            //get open threads

            $openThreads = $this->case->GetOpenThreads( $currentDelegation['APP_UID'] );

            //if we are derivating to finish process but there are no more open thread then we are finishing only the task, we are not finishing the whole process

            if (($nextDel['TAS_UID'] == TASK_FINISH_PROCESS) && (($openThreads + 1) > 1)) {

                $nextDel['TAS_UID'] = TASK_FINISH_TASK;

            }



            $taskNextDel = TaskPeer::retrieveByPK($nextDel["TAS_UID"]); //Get data for next delegation (next Task)

            $bpmnActivityNextDel = BpmnActivityPeer::retrieveByPK($nextDel["TAS_UID"]);



            $flagTaskNextDelIsMultipleInstance = false;

            $flagTaskNextDelAssignTypeIsMultipleInstance = false;



            if (!is_null($taskNextDel) && !is_null($bpmnActivityNextDel)) {

                $flagTaskNextDelIsMultipleInstance = $bpmnActivityNextDel->getActType() == "TASK" && preg_match("/^(?:EMPTY|USERTASK|MANUALTASK)$/", $bpmnActivityNextDel->getActTaskType()) && $bpmnActivityNextDel->getActLoopType() == "PARALLEL";

                $flagTaskNextDelAssignTypeIsMultipleInstance = preg_match("/^(?:MULTIPLE_INSTANCE|MULTIPLE_INSTANCE_VALUE_BASED)$/", $taskNextDel->getTasAssignType());

            }



            $flagUpdateCounters = true;



            switch ($nextDel['TAS_UID']) {

                case TASK_FINISH_PROCESS:

                    /*Close all delegations of $currentDelegation['APP_UID'] */

                    $this->case->closeAllDelegations( $currentDelegation['APP_UID'] );

                    $this->case->closeAllThreads( $currentDelegation['APP_UID'] );

                    //I think we need to change the APP_STATUS to completed,



                    //BpmnEvent - END-MESSAGE-EVENT, END-EMAIL-EVENT

                    if (isset($nextDel["TAS_UID_DUMMY"])) {

                        $taskDummy = TaskPeer::retrieveByPK($nextDel["TAS_UID_DUMMY"]);



                        switch ($taskDummy->getTasType()) {

                            case "END-MESSAGE-EVENT":

                                //Throw Message-Events - BpmnEvent - END-MESSAGE-EVENT

                                $case = new \ProcessMaker\BusinessModel\Cases();



                                $case->throwMessageEventBetweenElementOriginAndElementDest($currentDelegation["TAS_UID"], $nextDel["TAS_UID_DUMMY"], $appFields);

                                break;

                            case "END-EMAIL-EVENT":

                                //Email Event

                                $emailEvent = new \ProcessMaker\BusinessModel\EmailEvent();



                                $emailEvent->emailEventBetweenElementOriginAndElementDest($currentDelegation["TAS_UID"], $nextDel["TAS_UID_DUMMY"], $appFields);

                                break;

                        }

                    }

                    break;

                case TASK_FINISH_TASK:

                    $iAppThreadIndex = $appFields['DEL_THREAD'];

                    $this->case->closeAppThread( $currentDelegation['APP_UID'], $iAppThreadIndex );

                    break;

                default:

                    //Get all siblingThreads

                    $canDerivate = false;



                    switch ($currentDelegation['TAS_ASSIGN_TYPE']) {

                        case 'CANCEL_MI':

                        case 'STATIC_MI':

                            $arrayOpenThread = $this->case->GetAllOpenDelegation($currentDelegation);

                            $aData = $this->case->loadCase( $currentDelegation['APP_UID'] );



                            if (isset( $aData['APP_DATA'][str_replace( '@@', '', $currentDelegation['TAS_MI_INSTANCE_VARIABLE'] )] )) {

                                $sMIinstanceVar = $aData['APP_DATA'][str_replace( '@@', '', $currentDelegation['TAS_MI_INSTANCE_VARIABLE'] )];

                            } else {

                                $sMIinstanceVar = $aData['APP_DATA']['TAS_MI_INSTANCE_VARIABLE'];

                            }



                            if (isset( $aData['APP_DATA'][str_replace( '@@', '', $currentDelegation['TAS_MI_COMPLETE_VARIABLE'] )] )) {

                                $sMIcompleteVar = $aData['APP_DATA'][str_replace( '@@', '', $currentDelegation['TAS_MI_COMPLETE_VARIABLE'] )];

                            } else {

                                $sMIcompleteVar = $aData['APP_DATA']['TAS_MI_COMPLETE_VARIABLE'];

                            }



                            $discriminateThread = $sMIinstanceVar - $sMIcompleteVar;



                            // -1 because One App Delegation is closed by above Code

                            if ($discriminateThread == count($arrayOpenThread)) {

                                $canDerivate = true;

                            } else {

                                $canDerivate = false;

                            }

                            break;

                        default:

                            $routeType = $currentDelegation["ROU_TYPE"];

                            $routeType = ($flagTaskIsMultipleInstance && $flagTaskAssignTypeIsMultipleInstance)? "SEC-JOIN" : $routeType;



                            switch ($routeType) {

                                case "SEC-JOIN":

                                    $arrayOpenThread = ($flagTaskIsMultipleInstance && $flagTaskAssignTypeIsMultipleInstance)? $this->case->searchOpenPreviousTasks($currentDelegation["TAS_UID"], $currentDelegation["APP_UID"]) : array();

                                    $arrayOpenThread = array_merge($arrayOpenThread, $this->case->getOpenSiblingThreads($nextDel["TAS_UID"], $currentDelegation["APP_UID"], $currentDelegation["DEL_INDEX"], $currentDelegation["TAS_UID"]));



                                    $canDerivate = empty($arrayOpenThread);

                                    break;

                                default:

                                    $canDerivate = true;

                                    break;

                            }

                            break;

                    }



                    if ($canDerivate) {

                        //Throw Message-Events

                        $case = new \ProcessMaker\BusinessModel\Cases();



                        $case->throwMessageEventBetweenElementOriginAndElementDest($currentDelegation["TAS_UID"], $nextDel["TAS_UID"], $appFields);



                        //Throw Email-Events

                        $emailEvent = new \ProcessMaker\BusinessModel\EmailEvent();



                        $emailEvent->emailEventBetweenElementOriginAndElementDest($currentDelegation["TAS_UID"], $nextDel["TAS_UID"], $appFields);



                        //Derivate

                        $aSP = (isset($aSP))? $aSP : null;



                        $taskNextDelAssignType = ($flagTaskNextDelIsMultipleInstance && $flagTaskNextDelAssignTypeIsMultipleInstance)? $taskNextDel->getTasAssignType() : "";



                        switch ($taskNextDelAssignType) {

                            case "MULTIPLE_INSTANCE":

                            case "MULTIPLE_INSTANCE_VALUE_BASED":

                                $arrayUser = $this->getNextAssignedUser(array("APP_UID" => $currentDelegation["APP_UID"], "NEXT_TASK" => $taskNextDel->toArray(BasePeer::TYPE_FIELDNAME)));



                                if (empty($arrayUser)) {

                                    throw new Exception(G::LoadTranslation("ID_NO_USERS"));

                                }



                                foreach ($arrayUser as $value2) {

                                    $currentDelegationAux = array_merge($currentDelegation, array("ROU_TYPE" => "PARALLEL"));

                                    $nextDelAux = array_merge($nextDel, array("USR_UID" => $value2["USR_UID"]));



                                    $iNewDelIndex = $this->doDerivation($currentDelegationAux, $nextDelAux, $appFields, $aSP);



                                    $this->derivateUpdateCounters($currentDelegationAux, $nextDelAux, $taskNextDel, $appFields, $iNewDelIndex, $aSP, $removeList);



                                    $flagUpdateCounters = false;

                                    $removeList = false;

                                }

                                break;

                            default:

                                $iNewDelIndex = $this->doDerivation($currentDelegation, $nextDel, $appFields, $aSP);

                                break;

                        }



                        //Execute Script-Task

                        $scriptTask = new \ProcessMaker\BusinessModel\ScriptTask();



                        $appFields["APP_DATA"] = $scriptTask->execScriptByActivityUid($nextDel["TAS_UID"], $appFields);



                        //Create record in table APP_ASSIGN_SELF_SERVICE_VALUE

                        $regexpTaskTypeToExclude = "SCRIPT-TASK";



                        if (!is_null($taskNextDel) && !preg_match("/^(?:" . $regexpTaskTypeToExclude . ")$/", $taskNextDel->getTasType())) {

                            if ($taskNextDel->getTasAssignType() == "SELF_SERVICE" && trim($taskNextDel->getTasGroupVariable()) != "") {

                                $nextTaskGroupVariable = trim($taskNextDel->getTasGroupVariable(), " @#");



                                if (isset($appFields["APP_DATA"][$nextTaskGroupVariable])) {

                                    $dataVariable = $appFields["APP_DATA"][$nextTaskGroupVariable];

                                    $dataVariable = (is_array($dataVariable))? $dataVariable : trim($dataVariable);



                                    if (!empty($dataVariable)) {

                                        $appAssignSelfServiceValue = new AppAssignSelfServiceValue();



                                        $appAssignSelfServiceValue->create($appFields["APP_UID"], $iNewDelIndex, array("PRO_UID" => $appFields["PRO_UID"], "TAS_UID" => $nextDel["TAS_UID"], "GRP_UID" => serialize($dataVariable)));

                                    }

                                }

                            }

                        }



                        //Check if $taskNextDel is Script-Task

                        if (!is_null($taskNextDel) && $taskNextDel->getTasType() == "SCRIPT-TASK") {

                            $this->case->CloseCurrentDelegation($currentDelegation["APP_UID"], $iNewDelIndex);



                            //Get for $nextDel["TAS_UID"] your next Task

                            $taskNextDelNextDelegations = $this->prepareInformation(array(

                                "USER_UID"  => $_SESSION["USER_LOGGED"],

                                "APP_UID"   => $_SESSION["APPLICATION"],

                                "DEL_INDEX" => $iNewDelIndex

                            ));



                            //New next delegation

                            $newNextDelegation = array();



                            $newNextDelegation[1] = array(

                                "TAS_UID"           => $taskNextDelNextDelegations[1]["NEXT_TASK"]["TAS_UID"],

                                "USR_UID"           => $taskNextDelNextDelegations[1]["NEXT_TASK"]["USER_ASSIGNED"]["USR_UID"],

                                "TAS_ASSIGN_TYPE"   => $taskNextDelNextDelegations[1]["NEXT_TASK"]["TAS_ASSIGN_TYPE"],

                                "TAS_DEF_PROC_CODE" => "",

                                "DEL_PRIORITY"      => "",

                                "TAS_PARENT"        => ""

                            );



                            $this->derivate($currentDelegation, $newNextDelegation, $removeList);

                        }

                    } else {

                        //when the task doesnt generate a new AppDelegation

                        $iAppThreadIndex = $appFields['DEL_THREAD'];



                        $routeType = $currentDelegation["ROU_TYPE"];

                        $routeType = ($flagTaskIsMultipleInstance && $flagTaskAssignTypeIsMultipleInstance)? "SEC-JOIN" : $routeType;



                        switch ($routeType) {

                            case 'SEC-JOIN':

                                $this->case->closeAppThread( $currentDelegation['APP_UID'], $iAppThreadIndex );

                                break;

                            default:

                                if ($currentDelegation['TAS_ASSIGN_TYPE'] == 'STATIC_MI' || $currentDelegation['TAS_ASSIGN_TYPE'] == 'CANCEL_MI') {

                                    $this->case->closeAppThread( $currentDelegation['APP_UID'], $iAppThreadIndex );

                                }

                                break;

                        }

                    }

                    break;

            }



            if ($flagUpdateCounters) {

                $this->derivateUpdateCounters($currentDelegation, $nextDel, $taskNextDel, $appFields, (isset($iNewDelIndex))? $iNewDelIndex : 0, (isset($aSP))? $aSP : null, $removeList);

            }



            $removeList = false;



            unset($aSP);

        }



        /* Start Block : UPDATES APPLICATION */



        //Set THE APP_STATUS

        $appFields['APP_STATUS'] = $currentDelegation['APP_STATUS'];

        /* Start Block : Count the open threads of $currentDelegation['APP_UID'] */

        $openThreads = $this->case->GetOpenThreads( $currentDelegation['APP_UID'] );



        ///////

        $flag = false;



        if ($openThreads == 0) {

            //Close case

            $appFields["APP_STATUS"] = "COMPLETED";

            $appFields["APP_FINISH_DATE"] = "now";

            $this->verifyIsCaseChild($currentDelegation["APP_UID"], $currentDelegation["DEL_INDEX"]);



            $flag = true;

        }



        if (isset( $iNewDelIndex )) {

            $appFields["DEL_INDEX"] = $iNewDelIndex;

            $appFields["TAS_UID"] = $nextDel["TAS_UID"];



            $flag = true;

        }



        if ($flag) {

            //Start Block : UPDATES APPLICATION

            $this->case->updateCase( $currentDelegation["APP_UID"], $appFields );

            //End Block : UPDATES APPLICATION

        }

    }
 /**
  * Populates the object using an array.
  *
  * This is particularly useful when populating an object from one of the
  * request arrays (e.g. $_POST).  This method goes through the column
  * names, checking to see whether a matching key exists in populated
  * array. If so the setByName() method is called for that column.
  *
  * You can specify the key type of the array by additionally passing one
  * of the class type constants TYPE_PHPNAME, TYPE_COLNAME, TYPE_FIELDNAME,
  * TYPE_NUM. The default key type is the column's phpname (e.g. 'authorId')
  *
  * @param      array  $arr     An array to populate the object from.
  * @param      string $keyType The type of keys the array uses.
  * @return     void
  */
 public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
 {
     $keys = BpmnActivityPeer::getFieldNames($keyType);
     if (array_key_exists($keys[0], $arr)) {
         $this->setActUid($arr[$keys[0]]);
     }
     if (array_key_exists($keys[1], $arr)) {
         $this->setPrjUid($arr[$keys[1]]);
     }
     if (array_key_exists($keys[2], $arr)) {
         $this->setProUid($arr[$keys[2]]);
     }
     if (array_key_exists($keys[3], $arr)) {
         $this->setActName($arr[$keys[3]]);
     }
     if (array_key_exists($keys[4], $arr)) {
         $this->setActType($arr[$keys[4]]);
     }
     if (array_key_exists($keys[5], $arr)) {
         $this->setActIsForCompensation($arr[$keys[5]]);
     }
     if (array_key_exists($keys[6], $arr)) {
         $this->setActStartQuantity($arr[$keys[6]]);
     }
     if (array_key_exists($keys[7], $arr)) {
         $this->setActCompletionQuantity($arr[$keys[7]]);
     }
     if (array_key_exists($keys[8], $arr)) {
         $this->setActTaskType($arr[$keys[8]]);
     }
     if (array_key_exists($keys[9], $arr)) {
         $this->setActImplementation($arr[$keys[9]]);
     }
     if (array_key_exists($keys[10], $arr)) {
         $this->setActInstantiate($arr[$keys[10]]);
     }
     if (array_key_exists($keys[11], $arr)) {
         $this->setActScriptType($arr[$keys[11]]);
     }
     if (array_key_exists($keys[12], $arr)) {
         $this->setActScript($arr[$keys[12]]);
     }
     if (array_key_exists($keys[13], $arr)) {
         $this->setActLoopType($arr[$keys[13]]);
     }
     if (array_key_exists($keys[14], $arr)) {
         $this->setActTestBefore($arr[$keys[14]]);
     }
     if (array_key_exists($keys[15], $arr)) {
         $this->setActLoopMaximum($arr[$keys[15]]);
     }
     if (array_key_exists($keys[16], $arr)) {
         $this->setActLoopCondition($arr[$keys[16]]);
     }
     if (array_key_exists($keys[17], $arr)) {
         $this->setActLoopCardinality($arr[$keys[17]]);
     }
     if (array_key_exists($keys[18], $arr)) {
         $this->setActLoopBehavior($arr[$keys[18]]);
     }
     if (array_key_exists($keys[19], $arr)) {
         $this->setActIsAdhoc($arr[$keys[19]]);
     }
     if (array_key_exists($keys[20], $arr)) {
         $this->setActIsCollapsed($arr[$keys[20]]);
     }
     if (array_key_exists($keys[21], $arr)) {
         $this->setActCompletionCondition($arr[$keys[21]]);
     }
     if (array_key_exists($keys[22], $arr)) {
         $this->setActOrdering($arr[$keys[22]]);
     }
     if (array_key_exists($keys[23], $arr)) {
         $this->setActCancelRemainingInstances($arr[$keys[23]]);
     }
     if (array_key_exists($keys[24], $arr)) {
         $this->setActProtocol($arr[$keys[24]]);
     }
     if (array_key_exists($keys[25], $arr)) {
         $this->setActMethod($arr[$keys[25]]);
     }
     if (array_key_exists($keys[26], $arr)) {
         $this->setActIsGlobal($arr[$keys[26]]);
     }
     if (array_key_exists($keys[27], $arr)) {
         $this->setActReferer($arr[$keys[27]]);
     }
     if (array_key_exists($keys[28], $arr)) {
         $this->setActDefaultFlow($arr[$keys[28]]);
     }
     if (array_key_exists($keys[29], $arr)) {
         $this->setActMasterDiagram($arr[$keys[29]]);
     }
 }