<?php
/**
 * class.processes.php
 * @package workflow.engine.ProcessMaker
 *
 * ProcessMaker Open Source Edition
 * Copyright (C) 2004 - 2008 Colosa Inc.23
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * For more information, contact Colosa Inc, 2566 Le Jeune Rd.,
 * Coral Gables, FL, 33134, USA, or email info@colosa.com.
 */ 

require_once 'classes/model/Content.php';
require_once 'classes/model/Process.php';
require_once 'classes/model/Task.php';
require_once 'classes/model/Route.php';
require_once 'classes/model/SwimlanesElements.php';
require_once 'classes/model/InputDocument.php';
require_once 'classes/model/ObjectPermission.php';
require_once 'classes/model/OutputDocument.php';
require_once 'classes/model/Step.php';
require_once 'classes/model/StepTrigger.php';
require_once 'classes/model/Dynaform.php';
require_once 'classes/model/Triggers.php';
require_once 'classes/model/Groupwf.php';
require_once 'classes/model/ReportTable.php';
require_once 'classes/model/ReportVar.php';
require_once 'classes/model/DbSource.php';
require_once 'classes/model/StepSupervisor.php';
require_once 'classes/model/SubProcess.php';
require_once 'classes/model/CaseTracker.php';
require_once 'classes/model/CaseTrackerObject.php';
require_once 'classes/model/Stage.php';
require_once 'classes/model/TaskUser.php';
require_once 'classes/model/FieldCondition.php';
require_once 'classes/model/Event.php';
require_once 'classes/model/CaseScheduler.php';

G::LoadClass('tasks');
G::LoadClass('reportTables');
G::LoadClass('processMap');
G::LoadThirdParty('pear/json','class.json');

class Processes {

  /**
  * change Status of any Process
  * @param string $sProUid
  * @return boolean
  * @package workflow.engine.ProcessMaker
  */
  function changeStatus ( $sProUid = '') {
    $oProcess = new Process();
    $Fields = $oProcess->Load( $sProUid );
    $proFields['PRO_UID'] = $sProUid;
    if ( $Fields['PRO_STATUS'] == 'ACTIVE' )
      $proFields['PRO_STATUS'] = 'INACTIVE';
    else
      $proFields['PRO_STATUS'] = 'ACTIVE';

    $oProcess->Update( $proFields );
  }
  
  /**
  * change debug mode of any Process
  * @param string $sProUid
  * @return boolean
  * @package workflow.engine.ProcessMaker
  */
  function changeDebugMode ( $sProUid = '') {
    $oProcess = new Process();
    $Fields = $oProcess->Load( $sProUid );
    $proFields['PRO_UID'] = $sProUid;
    if ( $Fields['PRO_DEBUG'] == '1' )
      $proFields['PRO_DEBUG'] = '0';
    else
      $proFields['PRO_DEBUG'] = '1';

    $oProcess->Update( $proFields );
  }

 /**
  * changes in DB the parent GUID
  * @param $sProUid process uid
  * @param $sParentUid process parent uid
  * @return $sProUid
  */
  function changeProcessParent( $sProUid, $sParentUid) {
    $oProcess = new Process();
    $Fields = $oProcess->Load( $sProUid );
    $proFields['PRO_UID'] = $sProUid;
    $Fields['PRO_PARENT'] == $sParentUid;
    $oProcess->Update( $proFields );
  }

 /**
  * verify if the process $sProUid exists
  * @param string $sProUid
  * @return boolean
  */
  function processExists ( $sProUid = '') {
    $oProcess = new Process();
    return $oProcess->processExists( $sProUid );
  }

 /**
  * get an unused process GUID
  * @return $sProUid
  */
  function getUnusedProcessGUID( ) {
    do {
     $sNewProUid = G::generateUniqueID() ;
    } while ( $this->processExists ( $sNewProUid ) );
    return $sNewProUid;
  }

 /**
  * verify if the task  $sTasUid exists
  * @param string $sTasUid
  * @return boolean
  */
  function taskExists ( $sTasUid = '') {
    $oTask = new Task();
    return $oTask->taskExists( $sTasUid );
  }

 /**
  * get an unused task GUID
  * @return $sTasUid
  */
  function getUnusedTaskGUID( ) {
    do {
     $sNewTasUid = G::generateUniqueID() ;
    } while ( $this->taskExists ( $sNewTasUid ) );
    return $sNewTasUid;
  }

 /**
  * verify if the dynaform $sDynUid exists
  * @param string $sDynUid
  * @return boolean
  */
  function dynaformExists ( $sDynUid = '') {
    $oDynaform = new Dynaform();
    return $oDynaform->dynaformExists( $sDynUid );
  }

 /**
  * verify if the object exists
  * @param string $sUid
  * @return boolean
  */
  function inputExists ( $sUid = '') {
    $oInput = new InputDocument();
    return $oInput->inputExists( $sUid );
  }


 /**
  * verify if the object exists
  * @param string $sUid
  * @return boolean
  */
  function outputExists ( $sUid = '') {
    $oOutput = new OutputDocument();
    return $oOutput->outputExists( $sUid );
  }

 /**
  * verify if the object exists
  * @param string $sUid
  * @return boolean
  */
  function triggerExists ( $sUid = '') {
    $oTrigger = new Triggers();
    return $oTrigger->triggerExists( $sUid );
  }

 /**
  * verify if the object exists
  * @param string $sUid
  * @return boolean
  */
  function SubProcessExists ( $sUid = '') {
    $oSubProcess = new SubProcess();
    return $oSubProcess->subProcessExists( $sUid );
  }

 /**
  * verify if a caseTrackerObject object exists
  * @param string $sUid
  * @return boolean
  */
  function caseTrackerObjectExists ( $sUid = '') {
    $oCaseTrackerObject = new CaseTrackerObject();
    return $oCaseTrackerObject->caseTrackerObjectExists( $sUid );
  }

  /**
  * verify if a caseTracker Object exists
  * @param string $sUid
  * @return boolean
  */
  function caseTrackerExists ( $sUid = '') {
    $oCaseTracker = new CaseTracker();
    return $oCaseTracker->caseTrackerExists( $sUid );
  }

  /**
  * verify if a dbconnection exists
  * @param string $sUid
  * @return boolean
  */
  function dbConnectionExists ( $sUid = '') {
    $oDBSource = new DbSource();
    return $oDBSource->Exists( $sUid );
  }

  /**
  * verify if a objectPermission exists
  * @param string $sUid
  * @return boolean
  */
  function objectPermissionExists ( $sUid = '') {
    $oObjectPermission = new ObjectPermission();
    return $oObjectPermission->Exists( $sUid );
  }

  /**
  * verify if a route exists
  * @param string $sUid
  * @return boolean
  */
  function routeExists ( $sUid = '') {
    $oRoute = new Route();
    return $oRoute->routeExists( $sUid );
  }

  /**
  * verify if a stage exists
  * @param string $sUid
  * @return boolean
  */
  function stageExists ( $sUid = '') {
    $oStage = new Stage();
    return $oStage->Exists( $sUid );
  }

  /**
  * verify if a swimlane exists
  * @param string $sUid
  * @return boolean
  */
  function slExists ( $sUid = '') {
    $oSL = new SwimlanesElements();
    return $oSL->swimlanesElementsExists( $sUid );
  }

 /**
  * verify if a reportTable exists
  * @param string $sUid
  * @return boolean
  */
  function reportTableExists ( $sUid = '') {
    $oReportTable = new ReportTable();
    return $oReportTable->reportTableExists( $sUid );
  }

  /**
  * verify if a reportVar exists
  * @param string $sUid
  * @return boolean
  */
  function reportVarExists ( $sUid = '') {
    $oReportVar = new ReportVar();
    return $oReportVar->reportVarExists( $sUid );
  }

 /**
  * verify if a caseTrackerObject exists
  * @param string $sUid
  * @return boolean
  */
  function fieldsConditionsExists ( $sUid = '') {
    $oFieldCondition = new FieldCondition();
    return $oFieldCondition->Exists($sUid);
  }

 /**
  * verify if an event exists
  * @param string $sUid
  * @return boolean
  */
  function eventExists ( $sUid = '') {
    $oEvent = new Event();
    return $oEvent->Exists($sUid);
  }

 /**
  * verify if a caseScheduler exists
  * @param string $sUid
  * @return boolean
  */
  function caseSchedulerExists ( $sUid = '') {
    $oCaseScheduler = new CaseScheduler();
    return $oCaseScheduler->Exists($sUid);
  }


 /**
  * get an unused input GUID
  * @return $sProUid
  */
  function getUnusedInputGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->inputExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get an unused output GUID
  * @return $sProUid
  */
  function getUnusedOutputGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->outputExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get an unused trigger GUID
  * @return $sProUid
  */
  function getUnusedTriggerGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->triggerExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get an unused trigger GUID
  * @return $sProUid
  */
  function getUnusedSubProcessGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->subProcessExists ( $sNewUid ) );
    return $sNewUid;
  }
 /**
  * get a Unused CaseTrackerObject GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedCaseTrackerObjectGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->caseTrackerObjectExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get a Unused Database Source GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedDBSourceGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->dbConnectionExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get a Unused Object Permission GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedObjectPermissionGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->objectPermissionExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get a Unused Route GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedRouteGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->routeExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get a Unused Stage GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedStageGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->stageExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get a Unused SL GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedSLGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->slExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get a Unused Report Table GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedRTGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->reportTableExists ( $sNewUid ) );
    return $sNewUid;
  }

  /**
  * get a Unused Report Var GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedRTVGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->reportVarExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * verify if the object exists
  * @param string $sUid
  * @return boolean
  */
  function stepExists ( $sUid = '') {
    $oStep = new Step();
    return $oStep->stepExists( $sUid );
  }

 /**
  * get an unused step GUID
  * @return $sUid
  */
  function getUnusedStepGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->stepExists ( $sNewUid ) );
    return $sNewUid;
  }


  /*
  * get an unused Dynaform GUID
  * @return $sDynUid
  */
  function getUnusedDynaformGUID( ) {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->dynaformExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get a Unused Field Condition GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedFieldConditionGUID() {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this->fieldsConditionsExists ( $sNewUid ) );
    return $sNewUid;
  }

  /**
  * get a Unused Event GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedEventGUID() {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this-> eventExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * get a Unused Case Scheduler GUID
  * @return $sNewUid a new generated Uid
  */
  function getUnusedCaseSchedulerGUID() {
    do {
     $sNewUid = G::generateUniqueID() ;
    } while ( $this-> caseSchedulerExists ( $sNewUid ) );
    return $sNewUid;
  }

 /**
  * change the GUID for a serialized process
  * @param string $sProUid
  * @return boolean
  */
  function setProcessGUID( &$oData, $sNewProUid ) {
    $sProUid = $oData->process['PRO_UID'];
    $oData->process['PRO_UID'] = $sNewProUid;

    foreach ($oData->tasks as $key => $val ) {
      $oData->tasks[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->routes as $key => $val ) {
      $oData->routes[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->lanes as $key => $val ) {
      $oData->lanes[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->inputs as $key => $val ) {
      $oData->inputs[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->outputs as $key => $val ) {
      $oData->outputs[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->steps as $key => $val ) {
      $oData->steps[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->dynaforms as $key => $val ) {
      $oData->dynaforms[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->triggers as $key => $val ) {
      $oData->triggers[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->reportTables as $key => $val ) {
    $oData->reportTables[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->reportTablesVars as $key => $val ) {
    $oData->reportTablesVars[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->dbconnections as $key => $val ) {
      $oData->dbconnections[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->stepSupervisor as $key => $val ) {
    $oData->stepSupervisor[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->objectPermissions as $key => $val ) {
    $oData->objectPermissions[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->caseTracker as $key => $val ) {
    $oData->caseTracker[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->caseTrackerObject as $key => $val ) {
    $oData->caseTrackerObject[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->stage as $key => $val ) {
    $oData->stage[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->subProcess as $key => $val ) {
    $oData->subProcess[$key]['PRO_PARENT'] = $sNewProUid;
    }
    foreach ($oData->event as $key => $val ) {
    $oData->event[$key]['PRO_UID'] = $sNewProUid;
    }
    foreach ($oData->caseScheduler as $key => $val){
    $oData->caseScheduler[$key]['PRO_UID'] = $sNewProUid;
    }
    return true;
  }

 /**
  * change the GUID Parent for a serialized process, only in serialized data
  * @param string $sProUid
  * @return boolean
  */
  function setProcessParent( &$oData, $sParentUid ) {
    $oData->process['PRO_PARENT'] = $sParentUid;
    $oData->process['PRO_CREATE_DATE'] = date ('Y-m-d H:i:s');
    $oData->process['PRO_UPDATE_DATE'] = date ('Y-m-d H:i:s');
    return true;
  }

 /**
  * change and Renew all Task GUID, because the process needs to have a new set of tasks
  * @param string $oData
  * @return boolean
  */
  function renewAllTaskGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->tasks as $key => $val ) {
      $newGuid = $this->getUnusedTaskGUID();
      $map[ $val['TAS_UID'] ] = $newGuid;
      $oData->tasks[$key]['TAS_UID'] = $newGuid;
    }
    foreach ( $oData->routes as $key => $val ) {
      $newGuid = $map[ $val['TAS_UID'] ];
      $oData->routes[$key]['TAS_UID'] = $newGuid;
      if ( strlen ( $val['ROU_NEXT_TASK'] ) > 0 && $val['ROU_NEXT_TASK'] >0 ) {
        $newGuid = $map[ $val['ROU_NEXT_TASK'] ];
        $oData->routes[$key]['ROU_NEXT_TASK'] = $newGuid;
      }
    }
    foreach ( $oData->steps as $key => $val ) {
      $newGuid = $map[ $val['TAS_UID'] ];
      $oData->steps[$key]['TAS_UID'] = $newGuid;
    }
    foreach ( $oData->steptriggers as $key => $val ) {
      $newGuid = $map[ $val['TAS_UID'] ];
      $oData->steptriggers[$key]['TAS_UID'] = $newGuid;
    }
    foreach ( $oData->taskusers as $key => $val ) {
      $newGuid = $map[ $val['TAS_UID'] ];
      $oData->taskusers[$key]['TAS_UID'] = $newGuid;
    }
    foreach ( $oData->subProcess as $key => $val ) {
      $newGuid = $map[ $val['TAS_PARENT'] ];
      $oData->subProcess[$key]['TAS_PARENT'] = $newGuid;
      if (isset($map[ $val['TAS_UID'] ])) {
        $newGuid = $map[ $val['TAS_UID'] ];
        $oData->subProcess[$key]['TAS_UID'] = $newGuid;
      }
    }
    foreach ( $oData->objectPermissions as $key => $val ) {
      if (isset($map[ $val['TAS_UID'] ])) {
        $newGuid = $map[ $val['TAS_UID'] ];
        $oData->objectPermissions[$key]['TAS_UID'] = $newGuid;
      }
    }

    foreach ( $oData->caseScheduler as $key => $val ) {
      if (isset($map[ $val['TAS_UID'] ])) {
        $newGuid = $map[ $val['TAS_UID'] ];
        $oData->caseScheduler[$key]['TAS_UID'] = $newGuid;
      }
    }
    
  }

 /**
  * change and Renew all Dynaform GUID, because the process needs to have a new set of dynaforms
  * @param string $oData
  * @return boolean
  */
  function renewAllDynaformGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->dynaforms as $key => $val ) {
      $newGuid = $this->getUnusedDynaformGUID();
      $map[ $val['DYN_UID'] ] = $newGuid;
      $oData->dynaforms[$key]['DYN_UID'] = $newGuid;

    }
    foreach ( $oData->steps as $key => $val ) {
      if ( $val['STEP_TYPE_OBJ'] == 'DYNAFORM' ) {
        $newGuid = $map[ $val['STEP_UID_OBJ'] ];
        $oData->steps[$key]['STEP_UID_OBJ'] = $newGuid;
      }
    }
    foreach ( $oData->caseTrackerObject as $key => $val ) {
      if ( $val['CTO_TYPE_OBJ'] == 'DYNAFORM' ) {
        $newGuid = $map[ $val['CTO_UID_OBJ'] ];
        $oData->steps[$key]['CTO_UID_OBJ'] = $newGuid;
      }
    }
    foreach ( $oData->objectPermissions as $key => $val ) {
      if ( $val['OP_OBJ_TYPE'] == 'DYNAFORM' ) {
        $newGuid = $map[ $val['OP_OBJ_UID'] ];
        $oData->objectPermissions[$key]['OP_OBJ_UID'] = $newGuid;
      }
    }
    foreach ( $oData->stepSupervisor as $key => $val ) {
      if ( $val['STEP_TYPE_OBJ'] == 'DYNAFORM' ) {
        $newGuid = $map[ $val['STEP_UID_OBJ'] ];
        $oData->stepSupervisor[$key]['STEP_UID_OBJ'] = $newGuid;
      }
    }
    foreach ( $oData->dynaformFiles as $key => $val ) {
      $newGuid = $map[ $key ];
      $oData->dynaformFiles[$key] = $newGuid;
    }
    if(isset($oData->gridFiles)){
      foreach ( $oData->gridFiles as $key => $val ) {
        $newGuid = $map[ $key ];
        $oData->gridFiles[$key] = $newGuid;
      }
    }
    foreach( $oData->fieldCondition as  $key => $val ){
        $newGuid = $map[ $val['FCD_DYN_UID'] ];
        $oData->fieldCondition[$key]['FCD_DYN_UID'] = $newGuid;
    }

  }

 /**
  * get a Process with a search based in the process Uid
  * @param  $sProUid  string process Uid
  * @return $oProcess Process object
  */
  function getProcessRow ($sProUid,$getAllLang=false ){
    $oProcess = new Process( );
    return $oProcess->Load( $sProUid, $getAllLang );
  }

 /**
  * creates a process new process if a process exists with the same uid of the
  * $row['PRO_UID'] parameter then deletes it from the database and creates
  * a new one based on the $row parameter
  * @param  $row array parameter with the process data
  * @return $oProcess Process object
  */
  function createProcessRow ($row ){
    $oProcess = new Process( );
    if($oProcess->processExists ($row['PRO_UID']))
      { $oProcess->remove($row['PRO_UID']);
      }

    return $oProcess->createRow($row);
  }

 /**
  * Update a Process register in DB, if the process doesn't exists with the same
  * uid of the $row['PRO_UID'] parameter the function creates a new one based
  * on the $row parameter data.
  * @param  $row array parameter with the process data
  * @return $oProcess Process object
  */
  function updateProcessRow ($row ){
    $oProcess = new Process( );
    if($oProcess->processExists ($row['PRO_UID']))
      $oProcess->update($row);
    else
      $oProcess->create($row);
  }

 /**
  * Gets the subprocess data from a process and returns it in an array.
  * @param  $sProUid string for the process Uid
  * @return $aSubProcess array
  */
  function getSubProcessRow ($sProUid){
    try {
      $aSubProcess   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(SubProcessPeer::PRO_PARENT, $sProUid);
      $oDataset = SubProcessPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
       $aSubProcess[] = $aRow;
       $oDataset->next();
      }
      return $aSubProcess;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Gets a case Tracker Row from a process and returns it in an array.
  * @param  $sProUid string for the process Uid
  * @return $aCaseTracker array
  */

  function getCaseTrackerRow ($sProUid){
    try {
      $aCaseTracker = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(CaseTrackerPeer::PRO_UID, $sProUid);
      $oDataset = CaseTrackerPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
       $aCaseTracker[] = $aRow;
       $oDataset->next();
      }
      return $aCaseTracker;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Gets a case TrackerObject Row from a process and returns it in an array.
  * @param  $sProUid string for the process Uid
  * @return $aCaseTracker array
  */
  function getCaseTrackerObjectRow ($sProUid){
    try {
      $aCaseTrackerObject = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(CaseTrackerObjectPeer::PRO_UID, $sProUid);
      $oDataset = CaseTrackerObjectPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
       $aCaseTrackerObject[] = $aRow;
       $oDataset->next();
      }
      return $aCaseTrackerObject;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Gets a Stage Row from a process and returns it in an array.
  * @param  $sProUid string for the process Uid
  * @return $aStage array
  */
  function getStageRow ($sProUid){
    try {
      $aStage = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(StagePeer::PRO_UID, $sProUid);
      $oDataset = StagePeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oStage = new Stage();
        $aStage[] = $oStage->load($aRow['STG_UID']);
        $oDataset->next();
      }
      return $aStage;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Gets the Field Conditions from a process and returns those in an array.
  * @param  $sProUid string for the process Uid
  * @return $aFieldCondition array
  */

  function getFieldCondition($sProUid) {
    try {
        $aFieldCondition = array();
        $oCriteria = new Criteria('workflow');
        $oCriteria->add(DynaformPeer::PRO_UID, $sProUid);
        $oCriteria->addJoin (DynaformPeer::DYN_UID, FieldConditionPeer::FCD_DYN_UID );
        
        $oDataset = FieldConditionPeer::doSelectRS($oCriteria);
        $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
        $oDataset->next();
        while ($aRow = $oDataset->getRow()) {
            $aFieldCondition[] = $aRow;
            $oDataset->next();
        }
        return $aFieldCondition;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

/**
  * Gets the Event rows from a process and returns those in an array.
  * @param  $sProUid string for the process Uid
  * @return $aEvent array
  */
  function getEventRow($sProUid) {
    try {
      $aEvent = array();
      $oCriteria = new Criteria('workflow');
      
      $oCriteria->add(EventPeer::PRO_UID, $sProUid);
      $oDataset = EventPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oEvent = new Event();
        $aEvent[] = $oEvent->load($aRow['EVN_UID']);
        $oDataset->next();
      }
      return $aEvent; 
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Gets the Cases Scheduler rows from a process and returns those in an array.
  * @param  $sProUid string for the process Uid
  * @return $aCaseScheduler array
  */
  function getCaseSchedulerRow($sProUid) {
    try {
      $aCaseScheduler = array();
      $oCriteria = new Criteria('workflow');
      
      $oCriteria->add(CaseSchedulerPeer::PRO_UID, $sProUid);
      $oDataset = CaseSchedulerPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oCaseScheduler = new CaseScheduler();
        $aCaseScheduler[] = $oCaseScheduler->load($aRow['SCH_UID']);
        $oDataset->next();
      }
      return $aCaseScheduler; 
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }
  

 /**
  * Get all Swimlanes Elements for any Process
  * @param string $sProUid
  * @return array
  */
  public function getAllLanes($sProUid) {
    try {
      $aLanes   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(SwimlanesElementsPeer::PRO_UID,     $sProUid);
      $oDataset = SwimlanesElementsPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oSwim = new SwimlanesElements();
        $aLanes[] = $oSwim->Load($aRow['SWI_UID']);
        $oDataset->next();
      }
      return $aLanes;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Get Task Rows from a process and returns those in an array.
  * @param  $sProUid string for the process Uid
  * @return $oTask array
  */
  function getTaskRows ($sProUid ){
    $oTask = new Tasks( );
    return $oTask->getAllTasks( $sProUid );
  }

 /**
  * Create Task Rows from a $aTasks array data and returns those in an array.
  * @param  $aTasks array
  * @return $oTask array
  */
  function createTaskRows ($aTasks ){
    $oTask = new Tasks( );
    return $oTask->createTaskRows( $aTasks );
  }

 /**
  * Update Task Rows from a $aTasks array data and returns those in an array.
  * @param  $aTasks array
  * @return $oTask array
  */
  function updateTaskRows ($aTasks ){
    $oTask = new Tasks( );
    return $oTask->updateTaskRows( $aTasks );
  }

 /**
  * Gets all Route rows from a Process and returns those in an array.
  * @param  $sProUid string for the process Uid
  * @return $oTask Tasks array
  */
  function getRouteRows ($sProUid ){
    $oTask = new Tasks( );
    return $oTask->getAllRoutes( $sProUid );
  }

 /**
  * Create Route Rows from a $aRoutes array data and returns those in an array.
  * @param  $aRoutes array
  * @return $oTask Tasks array
  */
  function createRouteRows ($aRoutes ){
    $oTask = new Tasks( );
    return $oTask->createRouteRows( $aRoutes );
  }

 /**
  * Update Route Rows from a $aRoutes array data and returns those in an array.
  * @param  $aRoutes array
  * @return $oTask Tasks array
  */
  function updateRouteRows ($aRoutes ){
    $oTask = new Tasks( );
    return $oTask->updateRouteRows( $aRoutes );
  }

 /**
  * Get Lane Rows from a Process and returns those in an array.
  * @param  $sProUid string for the process Uid
  * @return array
  */
  function getLaneRows ($sProUid ){
    return $this->getAllLanes( $sProUid );
  }

  /**
  * Get Gateway Rows from a process and returns those in an array.
  * @param  $sProUid string for the process Uid
  * @return $oTask array
  */
  function getGatewayRows ($sProUid ){
    $oTask = new Tasks( );
    return $oTask->getAllGateways( $sProUid );
  }

   /**
  * Create Gateway Rows from a $aGateways array data and returns those in an array.
  * @param  $aGateways array
  * @return $oGateway array
  */
  function createGatewayRows ($aGateways ){
    $oTask = new Tasks( );
    return $oTask->createGatewayRows( $aGateways );
  }

 /**
  * Create Lane Rows from a $aLanes array data and returns those in an array.
  * @param  $aLanes array.
  * @return void
  */
  function createLaneRows ($aLanes ){
    foreach ( $aLanes as $key => $row ) {
      $oLane = new SwimlanesElements();
      if($oLane->swimlanesElementsExists($row['SWI_UID']))
          $oLane->remove($row['SWI_UID']);

      $res = $oLane->create($row);
    }
    return;
  }

 /**
  * Create Sub Process rows from an array, removing those subprocesses with
  * the same UID.
  * @param  $SubProcess array
  * @return void.
  */
  function createSubProcessRows ($SubProcess ){
    foreach ( $SubProcess as $key => $row ) {
      $oSubProcess = new SubProcess();
      if($oSubProcess->subProcessExists ($row['SP_UID']))
          $oSubProcess->remove($row['SP_UID']);

      $res = $oSubProcess->create($row);
    }
    return;
  }

 /**
  * Create Case Tracker rows from an array, removing those Trackers with
  * the same UID.
  * @param  $CaseTracker array.
  * @return void
  */
  function createCaseTrackerRows ($CaseTracker ){
    if ( is_array ( $CaseTracker) )
      foreach ( $CaseTracker as $key => $row ) {
        $oCaseTracker = new CaseTracker();
        if($oCaseTracker->caseTrackerExists ($row['PRO_UID']))
          $oCaseTracker->remove($row['PRO_UID']);
        $res = $oCaseTracker->create($row);
      }
    return;
  }

 /**
  * Create Case Tracker Objects rows from an array, removing those Objects
  * with the same UID, and recreaiting those from the array data.
  * @param  $CaseTrackerObject array.
  * @return void
  */
  function createCaseTrackerObjectRows ($CaseTrackerObject ) {
    foreach ( $CaseTrackerObject as $key => $row ) {
      $oCaseTrackerObject = new CaseTrackerObject();
      if($oCaseTrackerObject->caseTrackerObjectExists ($row['CTO_UID']))
          $oCaseTrackerObject->remove($row['CTO_UID']);
      $res = $oCaseTrackerObject->create($row);
    }
    return;
  }

 /**
  * Create Object Permissions rows from an array, removing those Objects
  * with the same UID, and recreaiting the records from the array data.
  * @param  $sProUid string for the process Uid.
  * @return void
  */
  function createObjectPermissionsRows ($ObjectPermissions ) {
    foreach ( $ObjectPermissions as $key => $row ) {
      $oObjectPermissions = new ObjectPermission();
      if($oObjectPermissions->Exists ($row['OP_UID']))
          $oObjectPermissions->remove($row['OP_UID']);
      $res = $oObjectPermissions->create($row);
    }
    return;
  }

 /**
  * Create Stage rows from an array, removing those Objects
  * with the same UID, and recreaiting the records from the array data.
  * @param  $Stage array.
  * @return void
  */
  function createStageRows ($Stage ) {
    foreach ( $Stage as $key => $row ) {
      $oStage = new Stage();
      if($oStage->Exists ($row['STG_UID']))
          $oStage->remove($row['STG_UID']);
      $res = $oStage->create($row);
    }
    return;
  }

 /**
  * Create Field Conditions from an array of Field Conditions and Dynaforms, 
  * removing those Objects with the same UID, and recreaiting the records
  * from the arrays data.
  * @param  $aFieldCondition array.
  * @param  $aDynaform array.
  * @return void
  */
  function createFieldCondition($aFieldCondition, $aDynaform ){
    if ( is_array ( $aFieldCondition ) )
      foreach ( $aFieldCondition as $key => $row ) {
        $oFieldCondition = new FieldCondition();
        if($oFieldCondition->fieldConditionExists ($row['FCD_UID'], $aDynaform) )
            $oFieldCondition->remove($row['FCD_UID']);
        $res = $oFieldCondition->create($row);
      }
    return;
  }

 /**
  * Create Event rows from an array, removing those Objects
  * with the same UID, and recreaiting the records from the array data.
  * @param  $Event array.
  * @return void
  */
  function createEventRows ($Event ) {
    foreach ( $Event as $key => $row ) {
      $oEvent = new Event();
      if($oEvent->Exists ($row['EVN_UID']))
          $oEvent->remove($row['EVN_UID']);
          
      $res = $oEvent->create($row);
    }
    return;
  }

 /**
  * Create Case Scheduler Rows from an array, removing those Objects
  * with the same UID, and recreaiting the records from the array data.
  * @param  $CaseScheduler array.
  * @return void
  */
  function createCaseSchedulerRows ($CaseScheduler ) {
    foreach ( $CaseScheduler as $key => $row ) {
      $oCaseScheduler = new CaseScheduler();
      if($oCaseScheduler->Exists($row['SCH_UID'])) 
          $oCaseScheduler->remove($row['SCH_UID']);
          
      $res = $oCaseScheduler->create($row);
    }
    return;
  }

 /**
  * Gets Input Documents Rows from aProcess.
  * @param  $sProUid string.
  * @return void
  */
  function getInputRows ($sProUid ){
    try {
      $aInput   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(InputdocumentPeer::PRO_UID,     $sProUid);
      $oDataset = InputdocumentPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oInput = new Inputdocument();
        $aInput[] = $oInput->Load( $aRow['INP_DOC_UID'] );
        $oDataset->next();
      }
      return $aInput;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Create Input Documents Rows from an array, removing those Objects
  * with the same UID, and recreaiting the records from the array data.
  * @param  $aInput array.
  * @return void
  */
  function createInputRows ($aInput ){
    foreach ( $aInput as $key => $row ) {
      $oInput = new Inputdocument();
      //unset ($row['TAS_UID']);
      if($oInput->InputExists ($row['INP_DOC_UID']))
          $oInput->remove($row['INP_DOC_UID']);

      $res = $oInput->create($row);
    }
    return;
  }

 /**
  * change and Renew all Input GUID, because the process needs to have a new set of Inputs
  * @param string $oData
  * @return boolean
  */
  function renewAllInputGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->inputs as $key => $val ) {
      $newGuid = $this->getUnusedInputGUID();
      $map[ $val['INP_DOC_UID'] ] = $newGuid;
      $oData->inputs[$key]['INP_DOC_UID'] = $newGuid;
    }
    foreach ( $oData->steps as $key => $val ) {
      if(isset($val['STEP_TYPE_OBJ'])){
          if ( $val['STEP_TYPE_OBJ'] == 'INPUT_DOCUMENT' ) {
            $newGuid = $map[ $val['STEP_UID_OBJ'] ];
            $oData->steps[$key]['STEP_UID_OBJ'] = $newGuid;
          }
      }
    }
    foreach ( $oData->caseTrackerObject as $key => $val ) {
      if ( $val['CTO_TYPE_OBJ'] == 'INPUT_DOCUMENT' ) {
        $newGuid = $map[ $val['CTO_UID_OBJ'] ];
        $oData->steps[$key]['CTO_UID_OBJ'] = $newGuid;
      }
    }
    foreach ( $oData->objectPermissions as $key => $val ) {
      if ( $val['OP_OBJ_TYPE'] == 'INPUT_DOCUMENT' ) {
        $newGuid = $map[ $val['OP_OBJ_UID'] ];
        $oData->objectPermissions[$key]['OP_OBJ_UID'] = $newGuid;
      }
    }
    foreach ( $oData->stepSupervisor as $key => $val ) {
      if ( $val['STEP_TYPE_OBJ'] == 'INPUT_DOCUMENT' ) {
        $newGuid = $map[ $val['STEP_UID_OBJ'] ];
        $oData->stepSupervisor[$key]['STEP_UID_OBJ'] = $newGuid;
      }
    }
  }

 /**
  * Gets the Output Documents Rows from a Process.
  * @param  $sProUid string.
  * @return $aOutput array
  */
  function getOutputRows ($sProUid ){
    try {
      $aOutput   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(OutputdocumentPeer::PRO_UID,     $sProUid);
      $oDataset = OutputdocumentPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oOutput = new Outputdocument();
        $aOutput[] = $oOutput->Load( $aRow['OUT_DOC_UID'] );
        $oDataset->next();
      }
      return $aOutput;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Create Input Documents Rows from an array, removing those Objects
  * with the same UID, and recreaiting the records from the array data.
  * @param  $aOutput array.
  * @return void
  */
  function createOutputRows ($aOutput ){
    foreach ( $aOutput as $key => $row ) {
      $oOutput = new Outputdocument();
      //unset ($row['TAS_UID']);
      if($oOutput->OutputExists ($row['OUT_DOC_UID']))
          $oOutput->remove($row['OUT_DOC_UID']);

      $res = $oOutput->create($row);
    }
    return;
  }

 /**
  * change and Renew all Output GUID, because the process needs to have a new set of Outputs
  * @param string $oData
  * @return boolean
  */
  function renewAllOutputGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->outputs as $key => $val ) {
      $newGuid = $this->getUnusedOutputGUID();
      $map[ $val['OUT_DOC_UID'] ] = $newGuid;
      $oData->outputs[$key]['OUT_DOC_UID'] = $newGuid;
    }
    foreach ( $oData->steps as $key => $val ) {
      if(isset($val['STEP_TYPE_OBJ'])){
          if ( $val['STEP_TYPE_OBJ'] == 'OUTPUT_DOCUMENT' ) {
            $newGuid = $map[ $val['STEP_UID_OBJ'] ];
            $oData->steps[$key]['STEP_UID_OBJ'] = $newGuid;
          }
      }
    }
    foreach ( $oData->caseTrackerObject as $key => $val ) {
      if ( $val['CTO_TYPE_OBJ'] == 'OUTPUT_DOCUMENT' ) {
        $newGuid = $map[ $val['CTO_UID_OBJ'] ];
        $oData->steps[$key]['CTO_UID_OBJ'] = $newGuid;
      }
    }
    foreach ( $oData->objectPermissions as $key => $val ) {
      if ( $val['OP_OBJ_TYPE'] == 'OUTPUT_DOCUMENT' ) {
        $newGuid = $map[ $val['OP_OBJ_UID'] ];
        $oData->objectPermissions[$key]['OP_OBJ_UID'] = $newGuid;
      }
    }
    foreach ( $oData->stepSupervisor as $key => $val ) {
      if ( $val['STEP_TYPE_OBJ'] == 'OUTPUT_DOCUMENT' ) {
        $newGuid = $map[ $val['STEP_UID_OBJ'] ];
        $oData->stepSupervisor[$key]['STEP_UID_OBJ'] = $newGuid;
      }
    }
  }

 /**
  * change and Renew all Trigger GUID, because the process needs to have a new set of Triggers
  * @param string $oData
  * @return boolean
  */
  function renewAllTriggerGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->triggers as $key => $val ) {
      $newGuid = $this->getUnusedTriggerGUID();
      $map[ $val['TRI_UID'] ] = $newGuid;
      $oData->triggers[$key]['TRI_UID'] = $newGuid;
    }
    foreach ( $oData->steptriggers as $key => $val ) {
      if (isset($map[ $val['TRI_UID'] ])) {
        $newGuid = $map[ $val['TRI_UID'] ];
        $oData->steptriggers[$key]['TRI_UID'] = $newGuid;
      }
      else {
        $oData->steptriggers[$key]['TRI_UID'] = $this->getUnusedTriggerGUID();
      }
    }
  }

 /**
  * Renew all the GUID's for Subprocesses
  * @param  $oData array.
  * @return void
  */
  function renewAllSubProcessGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->subProcess as $key => $val ) {
      $newGuid = $this->getUnusedSubProcessGUID();
      $map[ $val['SP_UID'] ] = $newGuid;
      $oData->subProcess[$key]['SP_UID'] = $newGuid;
    }
  }

 /**
  * Renew all the GUID's for Case Tracker Objects
  * @param  $oData array.
  * @return void
  */
  function renewAllCaseTrackerObjectGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->caseTrackerObject as $key => $val ) {
      $newGuid = $this->getUnusedCaseTrackerObjectGUID();
      $map[ $val['CTO_UID'] ] = $newGuid;
      $oData->caseTrackerObject[$key]['CTO_UID'] = $newGuid;
    }
  }

 /**
  * Renew all the GUID's for DB Sources
  * @param  $oData array.
  * @return void
  */
  function renewAllDBSourceGuid ( &$oData ) {
    $map = array ();
    $aSqlConnections = array(); 
    foreach ( $oData->dbconnections as $key => $val ) {
      $newGuid = $val['DBS_UID']; ///--  $this->getUnusedDBSourceGUID();
      $map[ $val['DBS_UID'] ] = $newGuid;
      $oData->dbconnections[$key]['DBS_UID'] = $newGuid;
    }
    $oData->sqlConnections = $map;
  }

 /**
  * Renew all the GUID's for Object Permissions
  * @param  $oData array.
  * @return void
  */
  function renewAllObjectPermissionGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->objectPermissions as $key => $val ) {
      $newGuid = $this->getUnusedObjectPermissionGUID();
      $map[ $val['OP_UID'] ] = $newGuid;
      $oData->objectPermissions[$key]['OP_UID'] = $newGuid;
    }
  }

 /**
  * Renew all the GUID's for Routes Objects
  * @param  $oData array.
  * @return void
  */
  function renewAllRouteGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->routes as $key => $val ) {
      $newGuid = $this->getUnusedRouteGUID();
      $map[ $val['ROU_UID'] ] = $newGuid;
      $oData->routes[$key]['ROU_UID'] = $newGuid;
    }
  }

 /**
  * Renew all the GUID's for Stage Objects
  * @param  $oData array.
  * @return void
  */
  function renewAllStageGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->stage as $key => $val ) {
      $newGuid = $this->getUnusedStageGUID();
      $map[ $val['STG_UID'] ] = $newGuid;
      $oData->stage[$key]['STG_UID'] = $newGuid;
    }
    foreach ( $oData->tasks as $key => $val ) {
      if (isset($map[ $val['STG_UID'] ])) {
        $newGuid = $map[ $val['STG_UID'] ];
        $oData->tasks[$key]['STG_UID'] = $newGuid;
      }
    }
  }
  
 /**
  * Renew all the GUID's for Swimlanes Elements Objects
  * @param  $oData array.
  * @return void
  */
  function renewAllSwimlanesElementsGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->lanes as $key => $val ) {
      $newGuid = $this->getUnusedSLGUID();
      $map[ $val['SWI_UID'] ] = $newGuid;
      $oData->lanes[$key]['SWI_UID'] = $newGuid;
    }
  }

 /**
  * Renew the GUID's for all the Report Tables Objects
  * @param  $oData array.
  * @return void
  */
  function renewAllReportTableGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->reportTables as $key => $val ) {
      $newGuid = $this->getUnusedRTGUID();
      $map[ $val['REP_TAB_UID'] ] = $newGuid;
      $oData->reportTables[$key]['REP_TAB_UID'] = $newGuid;
    }
    foreach ( $oData->reportTablesVars as $key => $val ) {
      $newGuid = $map[ $val['REP_TAB_UID'] ];
      $oData->reportTablesVars[$key]['REP_TAB_UID'] = $newGuid;
    }
  }

 /**
  * Renew all the GUID's for All The Report Vars Objects
  * @param  $oData array.
  * @return void
  */
  function renewAllReportVarGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->reportTablesVars as $key => $val ) {
      $newGuid = $this->getUnusedRTVGUID();
      $map[ $val['REP_VAR_UID'] ] = $newGuid;
      $oData->reportTablesVars[$key]['REP_VAR_UID'] = $newGuid;
    }
  }

 /**
  * Renew the GUID's for all the Field Conditions Objects
  * @param  $oData array.
  * @return void
  */
  function renewAllFieldCondition ( &$oData ) {
    $map = array ();
    foreach ( $oData->fieldCondition  as $key => $val ) {
      $newGuid = $this->getUnusedFieldConditionGUID();
      $map[ $val['FCD_UID'] ] = $newGuid;
      $oData->fieldCondition[$key]['FCD_UID'] = $newGuid;
    }
  } 

 /**
  * Renew the GUID's for all the Events Objects
  * @param  $oData array.
  * @return void
  */
  function renewAllEvent( &$oData ) {
    $map = array ();
    foreach ( $oData->event as $key => $val ) {
      $newGuid = $this->getUnusedEventGUID();
      $map[ $val['EVN_UID'] ] = $newGuid;
      $oData->event[$key]['EVN_UID'] = $newGuid;
    }
  }

 /**
  * Renew the GUID's for all Case Scheduler Objects
  * @param  $oData array.
  * @return void
  */
  function renewAllCaseScheduler( &$oData ) {
    $map = array ();
    foreach ( $oData->caseScheduler as $key => $val ) {
      $newGuid = $this->getUnusedCaseSchedulerGUID();
      $map[ $val['SCH_UID'] ] = $newGuid;
      $oData->caseScheduler[$key]['SCH_UID'] = $newGuid;
    }
  }

 /**
  * Renew the GUID's for all the Uids for all the elements
  * @param  $oData array.
  * @return void
  */
  function renewAll( &$oData ) {
    $this->renewAllTaskGuid ( $oData );
    $this->renewAllDynaformGuid ( $oData );
    $this->renewAllInputGuid ( $oData );
    $this->renewAllOutputGuid ( $oData );
    $this->renewAllStepGuid ( $oData );
    $this->renewAllTriggerGuid ( $oData );
    $this->renewAllSubProcessGuid ( $oData );
    $this->renewAllCaseTrackerObjectGuid ( $oData );
    $this->renewAllDBSourceGuid ( $oData );
    $this->renewAllObjectPermissionGuid ( $oData );
    $this->renewAllRouteGuid ( $oData );
    $this->renewAllStageGuid ( $oData );
    $this->renewAllSwimlanesElementsGuid ( $oData );
    $this->renewAllReportTableGuid ( $oData );
    $this->renewAllReportVarGuid ( $oData );
    $this->renewAllFieldCondition ( $oData );
    $this->renewAllEvent( $oData );
    $this->renewAllCaseScheduler( $oData );
  }

 /**
  * Get Step Rows from a Process
  * @param  $sProUid array.
  * @return array $aStep.
  */
  function getStepRows ($sProUid ){
    try {
      $aStep   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(StepPeer::PRO_UID,  $sProUid);
      $oDataset = StepPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oStep = new Step();
        $aStep[] = $oStep->Load( $aRow['STEP_UID'] );
        $oDataset->next();
      }
      return $aStep;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Create Step Rows from a Process
  * @param  $aStep array.
  * @return void.
  */
  function createStepRows ($aStep ){
    foreach ( $aStep as $key => $row ) {
      $oStep = new Step();
      if(isset($row['STEP_UID'])) {
          if($oStep->StepExists ($row['STEP_UID']))
              $oStep->remove($row['STEP_UID']);

          $res = $oStep->create($row);
      }
    }
    return;
  }

 /**
  * Create Step Supervisor Rows for a Process from an array of data
  * @param  $aStepSupervisor array.
  * @return void.
  */
  function createStepSupervisorRows($aStepSupervisor){
    foreach ($aStepSupervisor as $key => $row ) {
      $oStepSupervisor = new StepSupervisor();
    if( $oStepSupervisor->Exists($row['STEP_UID']) ) {
      $oStepSupervisor->remove($row['STEP_UID']);
    }
    $oStepSupervisor->create($row);
    }
  } #@!Neyek

 /**
  * change and Renew all Step GUID, because the process needs to have a new set of Steps
  * @param string $oData
  * @return boolean
  */
  function renewAllStepGuid ( &$oData ) {
    $map = array ();
    foreach ( $oData->steps as $key => $val ) {
      if(isset($val['STEP_UID'])) {
          $newGuid = $this->getUnusedStepGUID();
          $map[ $val['STEP_UID'] ] = $newGuid;
          $oData->steps[$key]['STEP_UID'] = $newGuid;
      }
    }
    foreach ( $oData->steptriggers as $key => $val ) {
      if ( $val['STEP_UID'] > 0 ) {
        if (isset($map[ $val['STEP_UID'] ])) {
          $newGuid = $map[ $val['STEP_UID'] ];
          $oData->steptriggers[$key]['STEP_UID'] = $newGuid;
        }
        else {
          $oData->steptriggers[$key]['STEP_UID'] = $this->getUnusedStepGUID();
        }
      }
    }
    foreach ( $oData->stepSupervisor as $key => $val ) {
      if ( $val['STEP_UID'] > 0 ) {
        if (isset($map[ $val['STEP_UID'] ])) {
          $newGuid = $map[ $val['STEP_UID'] ];
          $oData->stepSupervisor[$key]['STEP_UID'] = $newGuid;
        }
        else {
          $oData->stepSupervisor[$key]['STEP_UID'] = $this->getUnusedStepGUID();
        }
      }
    }
  }

 /**
  * Get Dynaform Rows from a Process
  * @param string $sProUid
  * @return $aDynaform array
  */
  function getDynaformRows ($sProUid ){
    try {
      $aDynaform   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(DynaformPeer::PRO_UID,  $sProUid);
      $oDataset = DynaformPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oDynaform = new Dynaform();
        $aDynaform[] = $oDynaform->Load( $aRow['DYN_UID'] );
        $oDataset->next();
      }
      return $aDynaform;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Get Object Permission Rows from a Process
  * @param string $sProUid
  * @return $aDynaform array
  */
  function getObjectPermissionRows ($sProUid ){ // by erik
    try {
      $oPermissions   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(ObjectPermissionPeer::PRO_UID,  $sProUid);
      $oCriteria->add(ObjectPermissionPeer::OP_USER_RELATION,  2);
      $oDataset = ObjectPermissionPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $o = new ObjectPermission();
        $oPermissions[] = $o->Load( $aRow['OP_UID'] );
        $oDataset->next();
      }
      return $oPermissions;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }#@!neyek

 /**
  * Create Dynaform Rows for a Process form an array
  * @param array $aDynaform
  * @return void
  */
  function createDynaformRows ($aDynaform ){
    foreach ( $aDynaform as $key => $row ) {
      $oDynaform = new Dynaform();
      //unset ($row['TAS_UID']);
      if($oDynaform->exists($row['DYN_UID']))
        $oDynaform->remove($row['DYN_UID']);

      $res = $oDynaform->create($row);
    }
    return;
  }
#@!neyek


 /**
  * Create Step Trigger Rows for a Process form an array
  * @param array $aStepTrigger
  * @return void
  */
  function createStepTriggerRows ($aStepTrigger ){
    foreach ( $aStepTrigger as $key => $row ) {
      $oStepTrigger = new StepTrigger();
      //unset ($row['TAS_UID']);
      if($oStepTrigger->stepTriggerExists ($row['STEP_UID'], $row['TAS_UID'], $row['TRI_UID'], $row['ST_TYPE']))
          $oStepTrigger->remove($row['STEP_UID'], $row['TAS_UID'], $row['TRI_UID'], $row['ST_TYPE']);

      $res = $oStepTrigger->createRow($row);
    }
    return;
  }

 /**
  * Get Step Trigger Rows for a Process form an array
  * @param array $aTask
  * @return array $aStepTrigger
  */
  function getStepTriggerRows ($aTask ){
    try {
      $aInTasks = array();
      foreach ( $aTask as $key => $val ) {
        $aInTasks[] = $val['TAS_UID'];
      }

      $aTrigger   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add( StepTriggerPeer::TAS_UID,  $aInTasks, Criteria::IN );
      $oDataset = StepTriggerPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      $aStepTrigger = array();
      while ($aRow = $oDataset->getRow()) {
        $aStepTrigger[] = $aRow;
        $oDataset->next();
      }
      return $aStepTrigger;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Get Step Trigger Rows for a Process form an array
  * @param array $aTask
  * @return array $aStepTrigger
  */
  function getTriggerRows ($sProUid ){
    try {
      $aTrigger   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add( TriggersPeer::PRO_UID,  $sProUid);
      $oDataset = TriggersPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oTrigger = new Triggers();
        $aTrigger[] = $oTrigger->Load( $aRow['TRI_UID'] );
        $oDataset->next();
      }
      return $aTrigger;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }
  
 /**
  * Create Step Trigger Rows for a Process form an array
  * @param array $aTrigger
  * @return void
  */
  function createTriggerRows ($aTrigger ){
    foreach ( $aTrigger as $key => $row ) {
      $oTrigger = new Triggers();
      //unset ($row['TAS_UID']);
      if($oTrigger->TriggerExists($row['TRI_UID']))
          $oTrigger->remove($row['TRI_UID']);

      $res = $oTrigger->create($row);
    }
    return;
  }

   /**
  * Get Groupwf Rows for a Process form an array
  * @param array $aGroups
  * @return array $aGroupwf
  */
  function getGroupwfRows ($aGroups ){
    try {
      $aInGroups = array();
      foreach ( $aGroups as $key => $val ) {
        $aInGroups[] = $val['USR_UID'];
      }

      $aGroupwf   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add( GroupwfPeer::GRP_UID,  $aInGroups, Criteria::IN );
      $oDataset = GroupwfPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oGroupwf = new Groupwf();
        $aGroupwf[] = $oGroupwf->Load( $aRow['GRP_UID'] );
        $oDataset->next();
      }
      return $aGroupwf;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Get DB Connections Rows for a Process
  * @param array $sProUid
  * @return array $aConnections
  */
  function getDBConnectionsRows($sProUid) {
    try {
      $aConnections = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(DbSourcePeer::PRO_UID, $sProUid);
      $oDataset = DbSourcePeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oConnection = new DbSource();
        $aConnections[] = $oConnection->Load($aRow['DBS_UID'], $aRow['PRO_UID']);
        $oDataset->next();
      }
      return $aConnections;
    }
    catch (Exception $oError) {
      throw $oError;
    }
  }

 /**
  * Get Step Supervisor Rows for a Process form an array
  * @param array $sProUid
  * @return array $aStepSup
  */
  function getStepSupervisorRows($sProUid)
  {
    try {
      $aConnections = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(StepSupervisorPeer::PRO_UID, $sProUid);
      $oDataset = StepSupervisorPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      $aStepSup = array();
      while ($aRow  = $oDataset->getRow()) {
        $aStepSup[] = $aRow;
        $oDataset->next();
      }
      return $aStepSup;
    }
    catch (Exception $oError) {
      throw $oError;
    }
  }

 /**
  * Get Report Tables Rows for a Process form an array
  * @param array $aTask
  * @return array $aReps
  */
  function getReportTablesRows($sProUid)
  {
    try {
      $aReps = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(ReportTablePeer::PRO_UID, $sProUid);
      $oDataset = ReportTablePeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oRep = new ReportTable();
        $aReps[] = $oRep->load($aRow['REP_TAB_UID']);
        $oDataset->next();
      }
      return $aReps;
    }
    catch (Exception $oError) {
      throw $oError;
    }
  }

 /**
  * Get Report Tables Vars Rows for a Process
  * @param string $sProUid
  * @return array $aRepVars
  */
  function getReportTablesVarsRows($sProUid)
  {
    try {
      $aRepVars = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(ReportVarPeer::PRO_UID, $sProUid);
      $oDataset = ReportVarPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oRepVar = new ReportVar();
        $aRepVars[] = $oRepVar->load($aRow['REP_VAR_UID']);
        $oDataset->next();
      }
      return $aRepVars;
    }
    catch (Exception $oError) {
      throw $oError;
    }
  }

 /**
  * Get Task User Rows for a Process
  * @param  array $aTask
  * @return array $aStepTrigger
  */
  function getTaskUserRows ($aTask ){
    try {
      $aInTasks = array();
      foreach ( $aTask as $key => $val ) {
        $aInTasks[] = $val['TAS_UID'];
      }

      $aTaskUser   = array();
      $oCriteria = new Criteria('workflow');
      $oCriteria->add( TaskUserPeer::TAS_UID,  $aInTasks, Criteria::IN );
      $oCriteria->add( TaskUserPeer::TU_RELATION,  2 );
      $oDataset = TaskUserPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $oCriteria2 = new Criteria('workflow');
        $oCriteria2->clearSelectColumns();
        $oCriteria2->addSelectColumn ( 'COUNT(*)' );
        $oCriteria2->add( GroupwfPeer::GRP_UID,    $aRow['USR_UID']);
        $oCriteria2->add( GroupwfPeer::GRP_STATUS, 'ACTIVE' );
        $oDataset2 = GroupwfPeer::doSelectRS($oCriteria2);
        //$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
        $oDataset2->next();
        $aRow2 = $oDataset2->getRow();
        $bActiveGroup = $aRow2[0];
        if ( $bActiveGroup == 1 )
          $aTaskUser[] = $aRow;
        $oDataset->next();
      }
      return $aTaskUser;
    }
    catch (Exception $oError) {
      throw($oError);
    }
  }

 /**
  * Get Task User Rows from an array of data
  * @param  array $aTaskUser
  * @return array $aStepTrigger
  */
  function createTaskUserRows ($aTaskUser ){
    foreach ( $aTaskUser as $key => $row ) {
      $oTaskUser = new TaskUser();
      if($oTaskUser->TaskUserExists ($row['TAS_UID'], $row['USR_UID'], $row['TU_TYPE'], $row['TU_RELATION']))
          $oTaskUser->remove($row['TAS_UID'], $row['USR_UID'], $row['TU_TYPE'], $row['TU_RELATION']);

      $res = $oTaskUser->create($row);
    }
    return;
  }

 /**
  * Get Task User Rows from an array of data
  * @param  array $aTaskUser
  * @return array $aStepTrigger
  */
  function createGroupRow ($aGroupwf ) {
    foreach ( $aGroupwf as $key => $row ) {
      $oGroupwf = new Groupwf();
      if ( $oGroupwf->GroupwfExists ( $row['GRP_UID'] ) ) {
         $oGroupwf->remove($row['GRP_UID']);
      }
      $res = $oGroupwf->create($row);
    }
  }

 /**
  * Create DB Connections rows from an array of data
  * @param  array $aConnections
  * @return void
  */
  function createDBConnectionsRows ($aConnections ) {
    foreach ( $aConnections as $sKey => $aRow ) {
      $oConnection = new DbSource();
      if( $oConnection->Exists($aRow['DBS_UID'], $aRow['PRO_UID']) ) {
       $oConnection->remove($aRow['DBS_UID'], $aRow['PRO_UID']);
      }
      $oConnection->create($aRow);
      
      // Update information in the table of contents
      $oContent = new Content();
      $ConCategory = 'DBS_DESCRIPTION';
      $ConParent =  '';
      $ConId = $aRow['DBS_UID'];
      $ConLang = SYS_LANG;
      if( $oContent->Exists($ConCategory, $ConParent, $ConId, $ConLang) ) {
        $oContent->removeContent($ConCategory, $ConParent, $ConId);
      }
      $oContent->addContent($ConCategory, $ConParent, $ConId, $ConLang);
    }
  } #@!neyek

 /**
  * Create Report Tables from an array of data
  * @param  array $aReportTables
  * @param  array $aReportTablesVars
  * @return void
  */
  function createReportTables($aReportTables, $aReportTablesVars)
  {
    $this->createReportTablesVars($aReportTablesVars);
    $oReportTables = new ReportTables();
    foreach ( $aReportTables as $sKey => $aRow ) {
      $bExists  = true;
      $sTable   = $aRow['REP_TAB_NAME'];
      $iCounter = 1;
      while ($bExists) {
        $oCriteria = new Criteria('workflow');
        $oCriteria->add(ReportTablePeer::REP_TAB_NAME, $sTable);
        $oDataset = ReportTablePeer::doSelectRS($oCriteria);
        $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
        $oDataset->next();
        $bExists = ($aRow2 = $oDataset->getRow());
        if ($bExists) {
          $sTable = $aRow['REP_TAB_NAME'] . '_' . $iCounter;
          $iCounter++;
        }
        else {
          $aRow['REP_TAB_NAME'] = $sTable;
        }
      }
      $aFields = $oReportTables->getTableVars($aRow['REP_TAB_UID'], true);
      $oReportTables->createTable($aRow['REP_TAB_NAME'], $aRow['REP_TAB_CONNECTION'], $aRow['REP_TAB_TYPE'], $aFields);
      $oReportTables->populateTable($aRow['REP_TAB_NAME'], $aRow['REP_TAB_CONNECTION'], $aRow['REP_TAB_TYPE'], $aFields, $aRow['PRO_UID'], $aRow['REP_TAB_GRID']);
      $aReportTables[$sKey]['REP_TAB_NAME'] = $aRow['REP_TAB_NAME'];
      $oRep = new ReportTable();
      if($oRep->reportTableExists ($aRow['REP_TAB_UID']))
          $oRep->remove($aRow['REP_TAB_UID']);
      $oRep->create($aRow);
    }
  } #@!neyek

 /**
  * Update Report Tables from an array of data
  * @param  array $aReportTables
  * @param  array $aReportTablesVars
  * @return void
  */
  function updateReportTables($aReportTables, $aReportTablesVars)
  {
    $this->cleanupReportTablesReferences($aReportTables);
    $this->createReportTables($aReportTables, $aReportTablesVars);
  } #@!neyek

 /**
  * Create Report Tables Vars from an array of data
  * @param  array $aReportTablesVars
  * @return void
  */
  function createReportTablesVars($aReportTablesVars)
  {
    foreach ( $aReportTablesVars as $sKey => $aRow ) {
      $oRep = new ReportVar();
      if($oRep->reportVarExists ($aRow['REP_VAR_UID']))
          $oRep->remove($aRow['REP_VAR_UID']);

      $oRep->create($aRow);
    }
  } #@!neyek

 /**
  * Cleanup Report Tables References from an array of data
  * @param  array $aReportTables
  * @return void
  */
  function cleanupReportTablesReferences($aReportTables)
  {
    foreach ( $aReportTables as $sKey => $aRow ) {
        $oReportTables = new ReportTables();
        $oReportTables->deleteReportTable($aRow['REP_TAB_UID']);
        $oReportTables->deleteAllReportVars($aRow['REP_TAB_UID']);
        $oReportTables->dropTable($aRow['REP_TAB_NAME']);
    }
  } #@!neyek

 /**
  * change Status of any Process
  * @param string $sProUid
  * @return boolean
  */
  function serializeProcess ( $sProUid = '') {
    $oProcess = new Process( );
    $oData->process           = $this->getProcessRow( $sProUid, false); 
    $oData->tasks             = $this->getTaskRows( $sProUid );
    $oData->routes            = $this->getRouteRows( $sProUid );
    $oData->lanes             = $this->getLaneRows( $sProUid );
    $oData->gateways          = $this->getGatewayRows( $sProUid );
    $oData->inputs            = $this->getInputRows( $sProUid );
    $oData->outputs           = $this->getOutputRows( $sProUid );
    $oData->dynaforms         = $this->getDynaformRows ( $sProUid );
    $oData->steps             = $this->getStepRows( $sProUid );
    $oData->triggers          = $this->getTriggerRows( $sProUid );
    $oData->taskusers         = $this->getTaskUserRows( $oData->tasks );
    $oData->groupwfs          = $this->getGroupwfRows( $oData->taskusers );
    $oData->steptriggers      = $this->getStepTriggerRows( $oData->tasks );
    $oData->dbconnections     = $this->getDBConnectionsRows($sProUid);
    $oData->reportTables      = $this->getReportTablesRows($sProUid);
    $oData->reportTablesVars  = $this->getReportTablesVarsRows($sProUid);
    $oData->stepSupervisor    = $this->getStepSupervisorRows($sProUid);
    $oData->objectPermissions = $this->getObjectPermissionRows ($sProUid);
    $oData->subProcess        = $this->getSubProcessRow ($sProUid);
    $oData->caseTracker       = $this->getCaseTrackerRow ($sProUid);
    $oData->caseTrackerObject = $this->getCaseTrackerObjectRow ($sProUid);
    $oData->stage             = $this->getStageRow ($sProUid);
    $oData->fieldCondition    = $this->getFieldCondition($sProUid);
    $oData->event             = $this->getEventRow ($sProUid);
    $oData->caseScheduler     = $this->getCaseSchedulerRow ($sProUid);
    //krumo ($oData);die;
    //$oJSON = new Services_JSON();
    //krumo ( $oJSON->encode($oData) );
    //return $oJSON->encode($oData); 
    return serialize($oData);
  }

 /**
  * Save a Serialized Process from an object
  * @param  array $oData
  * @return $result an array
  */
  function saveSerializedProcess ( $oData ) {
    //$oJSON = new Services_JSON();
    //$data = $oJSON->decode($oData);
    //$sProUid = $data->process->PRO_UID;
    $data = unserialize ($oData);
    $sProUid = $data->process['PRO_UID'];
    $path = PATH_DOCUMENT . 'output' . PATH_SEP;

    if ( !is_dir($path) ) {
        G::verifyPath($path, true);
    }
    $proTitle = (substr(G::inflect($data->process['PRO_TITLE']), 0, 30));
    $proTitle = preg_replace("[^A-Za-z0-9_]", "", $proTitle);


    $index = '';

    $lastIndex = '';

    do {
      $filename = $path . $proTitle . $index . '.pm';
      $lastIndex = $index;

      if ( $index == '' )
        $index = 1;
      else
        $index ++;
    } while ( file_exists ( $filename )  );


    $proTitle .= $lastIndex;

    $filenameOnly = $proTitle . '.pm';

    $fp = fopen( $filename.'tpm', "wb");

    $fsData = sprintf ( "%09d", strlen ( $oData) );
    $bytesSaved = fwrite( $fp, $fsData );  //writing the size of $oData
    $bytesSaved += fwrite( $fp, $oData ); //writing the $oData

    foreach ($data->dynaforms as $key => $val ) {
      $sFileName = PATH_DYNAFORM .  $val['DYN_FILENAME'] . '.xml';
      if ( file_exists ( $sFileName ) ) {
            $xmlGuid    = $val['DYN_UID'];
            $fsXmlGuid  = sprintf ( "%09d", strlen ( $xmlGuid ) );
            $bytesSaved += fwrite( $fp, $fsXmlGuid );  //writing the size of xml file
            $bytesSaved += fwrite( $fp, $xmlGuid );    //writing the xmlfile

            $xmlContent = file_get_contents ( $sFileName );
            $fsXmlContent = sprintf ( "%09d", strlen ( $xmlContent) );
            $bytesSaved += fwrite( $fp, $fsXmlContent );  //writing the size of xml file
            $bytesSaved += fwrite( $fp, $xmlContent );    //writing the xmlfile
      }

        $sFileName2 = PATH_DYNAFORM .  $val['DYN_FILENAME'] . '.html';
        if ( file_exists ( $sFileName2 ) ) {
            $htmlGuid    = $val['DYN_UID'];
            $fsHtmlGuid  = sprintf ( "%09d", strlen ( $htmlGuid ) );
            $bytesSaved += fwrite( $fp, $fsHtmlGuid );  //writing size dynaform id
            $bytesSaved += fwrite( $fp, $htmlGuid );    //writing dynaform id

            $htmlContent = file_get_contents ( $sFileName2 );
            $fsHtmlContent = sprintf ( "%09d", strlen ( $htmlContent ) );
            $bytesSaved += fwrite( $fp, $fsHtmlContent );  //writing the size of xml file
            $bytesSaved += fwrite( $fp, $htmlContent );    //writing the htmlfile
        }
    }
  /**
     * By <erik@colosa.com>
     * here we should work for the new functionalities
   * we have a many files for attach into this file
     *
     * here we go with the anothers files ;)
     */
  //before to do something we write a header into pm file for to do a differentiation between document types


  //create the store object
  //$file_objects = new ObjectCellection();

  // for mailtemplates files
  $MAILS_ROOT_PATH = PATH_DATA.'sites'.PATH_SEP.SYS_SYS.PATH_SEP.'mailTemplates'.PATH_SEP.$data->process['PRO_UID'];

  $isMailTempSent = false;
  $isPublicSent = false;
  //if this process have any mailfile
  if ( is_dir( $MAILS_ROOT_PATH ) ) {

    //get mail files list from this directory
    $file_list = scandir($MAILS_ROOT_PATH);

    foreach ($file_list as $filename) {
      // verify if this filename is a valid file, because it could be . or .. on *nix systems
      if($filename != '.' && $filename != '..'){
        if (@is_readable($MAILS_ROOT_PATH.PATH_SEP.$filename)) {
          $sFileName = $MAILS_ROOT_PATH . PATH_SEP . $filename;
          if ( file_exists ( $sFileName ) ) {
            if ( ! $isMailTempSent ) {
              $bytesSaved += fwrite( $fp, 'MAILTEMPL');
              $isMailTempSent = true;
            }
            //$htmlGuid    = $val['DYN_UID'];
            $fsFileName  = sprintf ( "%09d", strlen ( $filename ) );
            $bytesSaved += fwrite( $fp, $fsFileName );  //writing the fileName size
            $bytesSaved += fwrite( $fp, $filename );    //writing the fileName size

            $fileContent = file_get_contents ( $sFileName );
            $fsFileContent = sprintf ( "%09d", strlen ( $fileContent ) );
            $bytesSaved += fwrite( $fp, $fsFileContent );  //writing the size of xml file
            $bytesSaved += fwrite( $fp, $fileContent );    //writing the htmlfile
          }

        }
      }
    }
  }

  // for public files
  $PUBLIC_ROOT_PATH = PATH_DATA.'sites'.PATH_SEP.SYS_SYS.PATH_SEP.'public'.PATH_SEP.$data->process['PRO_UID'];

  //if this process have any mailfile
  if ( is_dir( $PUBLIC_ROOT_PATH ) ) {

    //get mail files list from this directory
    $file_list = scandir($PUBLIC_ROOT_PATH);

    foreach ($file_list as $filename) {
      // verify if this filename is a valid file, because it could be . or .. on *nix systems
      if($filename != '.' && $filename != '..'){
        if (@is_readable($PUBLIC_ROOT_PATH.PATH_SEP.$filename)) {
          $sFileName = $PUBLIC_ROOT_PATH . PATH_SEP . $filename;
          if ( file_exists ( $sFileName ) ) {
            if ( ! $isPublicSent ) {
              $bytesSaved += fwrite( $fp, 'PUBLIC   ');
              $isPublicSent = true;
            }
            //$htmlGuid    = $val['DYN_UID'];
            $fsFileName  = sprintf ( "%09d", strlen ( $filename ) );
            $bytesSaved += fwrite( $fp, $fsFileName );  //writing the fileName size
            $bytesSaved += fwrite( $fp, $filename );    //writing the fileName size

            $fileContent = file_get_contents ( $sFileName );
            $fsFileContent = sprintf ( "%09d", strlen ( $fileContent ) );
            $bytesSaved += fwrite( $fp, $fsFileContent );  //writing the size of xml file
            $bytesSaved += fwrite( $fp, $fileContent );    //writing the htmlfile
          }

        }
      }
    }
  }

/*
  // for public files
  $PUBLIC_ROOT_PATH = PATH_DATA.'sites'.PATH_SEP.SYS_SYS.PATH_SEP.'public'.PATH_SEP.$data->process['PRO_UID'];

  //if this process have any mailfile
  if ( is_dir( $PUBLIC_ROOT_PATH ) ) {

    //get mail files list from this directory
    $files_list = scandir($PUBLIC_ROOT_PATH);
    foreach ($file_list as $filename) {
      // verify if this filename is a valid file, beacuse it could be . or .. on *nix systems
      if($filename != '.' && $filename != '..'){
        if (@is_readable($PUBLIC_ROOT_PATH.PATH_SEP.$nombre_archivo)) {
          $tmp = explode('.', $filename);
          $ext = $tmp[1];
          $ext_fp = fopen($PUBLIC_ROOT_PATH.PATH_SEP.$nombre_archivo, 'r');
          $file_data = fread($ext_fp, filesize($PUBLIC_ROOT_PATH.PATH_SEP.$nombre_archivo));
          fclose($ext_fp);
          $file_objects->add($filename, $ext, $file_data,'public');
        }
      }
    }
  }

  //So,. we write the store object into pm export file
  $extended_data = serialize($file_objects);
  $bytesSaved += fwrite( $fp, $extended_data );
  */
  /* under here, I've not modified those lines */

    fclose ($fp);
    
    //$bytesSaved = file_put_contents  ( $filename  , $oData  );
    $filenameLink = 'processes_DownloadFile?p=' . $proTitle . '&r=' . rand(100,1000);
    $result['PRO_UID']          = $data->process['PRO_UID'];
    $result['PRO_TITLE']        = $data->process['PRO_TITLE'];
    $result['PRO_DESCRIPTION']  = $data->process['PRO_DESCRIPTION'];
    $result['SIZE']             = $bytesSaved;
    $result['FILENAME']         = $filenameOnly;
    $result['FILENAME_LINK']    = $filenameLink;
    return $result;
  }

 /**
  * Get the process Data form a filename
  * @param  array $pmFilename
  * @return void
  */
  function getProcessData ( $pmFilename  ) {
    $oProcess = new Process();
    if (! file_exists($pmFilename) )
      throw ( new Exception ( 'Unable to read uploaded file, please check permissions. '));

    if (! filesize($pmFilename) >= 9 )
      throw ( new Exception ( 'Uploaded file is corrupted, please check the file before continue. '));
    clearstatcache();
    $fp = fopen( $pmFilename, "rb");
    $fsData = intval( fread ( $fp, 9)); //reading the size of $oData
    $contents = '';
    $contents  = @fread( $fp, $fsData );    //reading string $oData

    if ($contents != '') {
      $oData = unserialize ($contents);
      if ($oData === false)
        throw new Exception("Process file is not valid");

      foreach($oData->dynaforms as $key => $value)
        {
          if($value['DYN_TYPE']=='grid')
           {  $oData->gridFiles[$value['DYN_UID'] ] = $value['DYN_UID'];
           }
        }
    
      $oData->dynaformFiles = array();
      $sIdentifier = 0;
      while ( !feof ( $fp ) && is_numeric ( $sIdentifier ) ) {
        $sIdentifier  = fread ( $fp, 9);      //reading the block identifier
        if ( is_numeric ( $sIdentifier ) ) {
        $fsXmlGuid    = intval( $sIdentifier );      //reading the size of $filename
          if ( $fsXmlGuid > 0 )
            $XmlGuid    = fread( $fp, $fsXmlGuid );    //reading string $XmlGuid

          $fsXmlContent = intval( fread ( $fp, 9));      //reading the size of $XmlContent
          if ( $fsXmlContent > 0 ) {
            $oData->dynaformFiles[$XmlGuid ] = $XmlGuid;
            $XmlContent   = fread( $fp, $fsXmlContent );    //reading string $XmlContent
            unset($XmlContent);
          }
        }
      }
    }
    else {
      $oData = null;
    }
    fclose ( $fp);
    return $oData;
  }
  
  // import process related functions

  /**
   * function checkExistingGroups
   * @author gustavo cruz gustavo-at-colosa.com
   * @param $sGroupList array of a group list
   * @return $existingGroupList array of existing groups or null
   * @desc  checkExistingGroups check if any of the groups listed in the parameter
   *        array exist and wich are those, that is the result $sFilteredGroups array.
   */
  function checkExistingGroups( $sGroupList ){

      $oCriteria = new Criteria('workflow');
      $oCriteria->addSelectColumn(GroupwfPeer::GRP_UID);
      $oCriteria->addSelectColumn(ContentPeer::CON_ID);
      $oCriteria->addSelectColumn(ContentPeer::CON_VALUE);
      $oCriteria->add( ContentPeer::CON_CATEGORY, 'GRP_TITLE');
      $oCriteria->add( ContentPeer::CON_LANG, 'en');
      $oCriteria->addJoin (ContentPeer::CON_ID, GroupwfPeer::GRP_UID);
      $oDataset = ContentPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $aGroupwf[] = $aRow;
        $oDataset->next();
      }
      //check if any group name exists in the dbase
      foreach ($aGroupwf as $groupBase){
        foreach ($sGroupList as $group){
          if($groupBase['CON_VALUE']==$group['GRP_TITLE']&&$groupBase['CON_ID']!=$group['GRP_UID']){
              $existingGroupList[]=$group;
          }
        }
      }

      //return $sGroupList;
      if (isset($existingGroupList))
        return $existingGroupList;
      else
        return null;

  }

  /**
   * function renameExistingGroups
   * @author gustavo cruz gustavo-at-colosa.com
   * @param  $sGroupList array of a group list
   * @return $renamedGroupList array of existing groups
   * @desc   renameExistingGroups check if any of the groups listed in the parameter
   *         array exist and wich are those, then rename the file adding a number
   *         suffix to the title atribute of each element of the $renamedGroupList array.
   */

  function renameExistingGroups( $sGroupList ){
    $checkedGroup = $this->checkExistingGroups($sGroupList);
    foreach ($sGroupList as $groupBase){
        foreach ($checkedGroup as $group){
          if($groupBase['GRP_TITLE']==$group['GRP_TITLE']){
            $index = substr($groupBase['GRP_TITLE'],-1,0);
              if (is_int($index)){
                $index++;
              } else {
                $index=1;
              }
            $groupBase['GRP_TITLE'] =  $groupBase['GRP_TITLE'].$index;
          }

        }
        $renamedGroupList[] = $groupBase;
    }

    if (isset($renamedGroupList))
        return $renamedGroupList;
      else
        return null;

  }

  /**
   * function mergeExistingGroups
   * @author gustavo cruz gustavo-at-colosa.com
   * @param  $sGroupList array of a group list
   * @return $mergedGroupList array of existing groups
   * @desc   mergeExistingGroups check if any of the groups listed in the parameter
   *         array exist and wich are those, then replaces the id of the elements in
   *         in the $mergedGroupList array.
   */
  function mergeExistingGroups( $sGroupList){

      $oCriteria = new Criteria('workflow');
      $oCriteria->addSelectColumn(GroupwfPeer::GRP_UID);
      $oCriteria->addSelectColumn(ContentPeer::CON_ID);
      $oCriteria->addSelectColumn(ContentPeer::CON_VALUE);
      $oCriteria->add( ContentPeer::CON_CATEGORY, 'GRP_TITLE');
      $oCriteria->add( ContentPeer::CON_LANG, 'en');
      $oCriteria->addJoin (ContentPeer::CON_ID, GroupwfPeer::GRP_UID);
      $oDataset = ContentPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      while ($aRow = $oDataset->getRow()) {
        $aGroupwf[] = $aRow;
        $oDataset->next();
      }
      //check if any group name exists in the dbase
     foreach ($sGroupList as $group){
       $merged = false;
       foreach ($aGroupwf as $groupBase){
          if($groupBase['CON_VALUE']==$group['GRP_TITLE']&&$groupBase['CON_ID']!=$group['GRP_UID']){
            $group['GRP_UID'] = $groupBase['CON_ID'];
            $mergedGroupList[]=$group;
            $merged = true;
          }
        }
        //
        if (!$merged){
            $mergedGroupList[]=$group;
        }
      }


      if (isset($mergedGroupList)){
        return $mergedGroupList;
      }
      else{
        return null;
      }
  }

  /**
   * function mergeExistingUsers
   * @author gustavo cruz gustavo-at-colosa.com
   * @param  $sBaseGroupList array of a group list with the original group list
   * @param  $sGroupList array of a group list with the merged group list
   * @param  $sTaskUserList array of the task user list, it contents the link between
   *         the task and the group list
   * @return $mergedTaskUserList array of the merged task user list
   * @desc   mergeExistingGroups check if any of the groups listed in the parameter
   *         array exist and wich are those, then replaces the id of the elements in
   *         in the $mergedGroupList array.
   */
  function mergeExistingUsers( $sBaseGroupList, $sGroupList, $sTaskUserList ){
    foreach ($sTaskUserList as $taskuser){
        $merged = false;
        foreach ($sBaseGroupList as $groupBase){
            foreach ($sGroupList as $group){
                // check if the group has been merged
                if($groupBase['GRP_TITLE']==$group['GRP_TITLE']&&$groupBase['GRP_UID']!=$group['GRP_UID']&&$groupBase['GRP_UID']==$taskuser['USR_UID']){
                    // merging the user id to match the merged group
                    $taskuser['USR_UID']=$group['GRP_UID'];
                    $mergedTaskUserList[] = $taskuser;
                    $merged=true;
                }
            }
        }
        //if hasn't been merged set the default value
        if(!$merged){
            $mergedTaskUserList[] = $taskuser;
        }
    }
    if (isset($mergedTaskUserList)){
        return $mergedTaskUserList;
    }
    else{
        return null;
    }
  }

  // end of import process related functions

  /**
   * disable all previous process with the parent $sProUid
   * @param $sProUid process uid
   * @return void
   */
  function disablePreviousProcesses( $sProUid ) {
    //change status of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(ProcessPeer::PRO_PARENT, $sProUid);
    $oDataset = ProcessPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    $oProcess = new Process();
    while ($aRow = $oDataset->getRow()) {
      $aRow['PRO_STATUS'] = 'DISABLED';
      $aRow['PRO_UPDATE_DATE'] = 'now';
      $oProcess->update ( $aRow);
      $oDataset->next();
    }

  }

  /**
   * create the files from a .pm file
   * @param $oData process data
   * @param $pmFilename process file name
   * @return boolean true
   */
  function createFiles ( $oData, $pmFilename  ) {
        if (! file_exists($pmFilename))
            throw ( new Exception ( 'Unable to read uploaded .pm file, please check permissions. ') );

        if (! filesize($pmFilename) >= 9 )
            throw ( new Exception ( 'Uploaded .pm file is corrupted, please check the file before continue. '));

        $fp = fopen( $pmFilename, "rb");
        $fsData = intval( fread ( $fp, 9));    //reading the size of $oData
        $contents  = fread( $fp, $fsData );    //reading string $oData

        $path = PATH_DYNAFORM . $oData->process['PRO_UID'] . PATH_SEP;
        if ( !is_dir($path) ) {
            G::verifyPath($path, true);
        }

        $sIdentifier = 1;
        while ( !feof ( $fp ) && is_numeric( $sIdentifier )  ) {
          $sIdentifier = fread ( $fp, 9);      //reading the size of $filename
          if ( is_numeric( $sIdentifier ) ) {
            $fsXmlGuid    = intval( $sIdentifier );      //reading the size of $filename
            if ( $fsXmlGuid > 0 )
                $XmlGuid    = fread( $fp, $fsXmlGuid );    //reading string $XmlGuid
            $fsXmlContent = intval( fread ( $fp, 9));      //reading the size of $XmlContent
            if ( $fsXmlContent > 0 ) {
              $newXmlGuid = $oData->dynaformFiles[ $XmlGuid ];
              if(isset($oData->process['PRO_UID_OLD'])){
                  $XmlContent   = fread( $fp, $fsXmlContent );    //reading string $XmlContent

                  $XmlContent = str_replace($oData->process['PRO_UID_OLD'], $oData->process['PRO_UID'], $XmlContent);
                  $XmlContent = str_replace($XmlGuid, $newXmlGuid, $XmlContent);

                  //foreach
                  if (isset($oData->gridFiles)) {
                    if (is_array($oData->gridFiles)) {
                      foreach($oData->gridFiles as $key => $value)
                      {
                          $XmlContent = str_replace($key, $value, $XmlContent);
                      }
                    }
                  }

                  if(isset($oData->sqlConnections)) {
                    foreach($oData->sqlConnections as $key => $value ){
                      $XmlContent = str_replace($key, $value, $XmlContent);
                    }
                    
                  }
                  
                  #here we verify if is adynaform or a html
                  $aAux = explode(' ', $XmlContent);
                  $ext = (strpos($aAux[0], '<?xml') !== false ? '.xml' : '.html');

                  $sFileName = $path . $newXmlGuid . $ext;
                  $bytesSaved = @file_put_contents ( $sFileName, $XmlContent );
                  //if ( $bytesSaved != $fsXmlContent ) throw ( new Exception ('Error writing dynaform file in directory : ' . $path ) );
              }
            }
          }
        }

        //now mailTemplates and public files
        $pathPublic  = PATH_DATA_SITE . 'public' . PATH_SEP . $oData->process['PRO_UID'] . PATH_SEP;
        $pathMailTem = PATH_DATA_SITE . 'mailTemplates' . PATH_SEP . $oData->process['PRO_UID'] . PATH_SEP;
        G::mk_dir ( $pathPublic );
        G::mk_dir ( $pathMailTem );

        if ( $sIdentifier == 'MAILTEMPL' ) {
          $sIdentifier = 1;
          while ( !feof ( $fp ) && is_numeric( $sIdentifier )  ) {
            $sIdentifier = fread ( $fp, 9);      //reading the size of $filename
            if ( is_numeric( $sIdentifier ) ) {
              $fsFileName    = intval( $sIdentifier );      //reading the size of $filename
              if ( $fsFileName > 0 )
                  $sFileName    = fread( $fp, $fsFileName );    //reading filename string
              $fsContent = intval( fread ( $fp, 9));      //reading the size of $Content
              if ( $fsContent > 0 ) {
                $fileContent   = fread( $fp, $fsContent );    //reading string $XmlContent
                $newFileName = $pathMailTem . $sFileName;
                $bytesSaved = @file_put_contents ( $newFileName, $fileContent );
                if ( $bytesSaved != $fsContent )
                throw ( new Exception ('Error writing MailTemplate file in directory : ' . $pathMailTem ) );
              }
            }
          }
        }

        if ( $sIdentifier == 'PUBLIC' ) {
          $sIdentifier = 1;
          while ( !feof ( $fp ) && is_numeric( $sIdentifier )  ) {
            $sIdentifier = fread ( $fp, 9);      //reading the size of $filename
            if ( is_numeric( $sIdentifier ) ) {
              $fsFileName    = intval( $sIdentifier );      //reading the size of $filename
              if ( $fsFileName > 0 )
                  $sFileName    = fread( $fp, $fsFileName );    //reading filename string
              $fsContent = intval( fread ( $fp, 9));      //reading the size of $Content
              if ( $fsContent > 0 ) {
                $fileContent   = fread( $fp, $fsContent );    //reading string $XmlContent
                $newFileName = $pathPublic . $sFileName;
                $bytesSaved = @file_put_contents ( $newFileName, $fileContent );
                if ( $bytesSaved != $fsContent )
                throw ( new Exception ('Error writing Public file in directory : ' . $pathPublic ) );
              }
            }
          }
        }

        fclose ( $fp);

        return true;

    }


 /**
  * this function remove all Process except the PROCESS ROW
  * @param string $sProUid
  * @return boolean
  */
  function removeProcessRows ($sProUid )  {
    try {
      //Instance all classes necesaries
      $oProcess         = new Process();
      $oDynaform        = new Dynaform();
      $oInputDocument   = new InputDocument();
      $oOutputDocument  = new OutputDocument();
      $oTrigger         = new Triggers();
      $oStepTrigger     = new StepTrigger();
      $oRoute           = new Route();
      $oStep            = new Step();
      $oSubProcess      = new SubProcess();
      $oCaseTracker     = new CaseTracker();
      $oCaseTrackerObject=new CaseTrackerObject();
      $oObjectPermission= new ObjectPermission();
      $oSwimlaneElement = new SwimlanesElements();
      $oConnection      = new DbSource();
      $oStage           = new Stage();
      $oEvent           = new Event();
      $oCaseScheduler   = new CaseScheduler();

      //Delete the tasks of process
      $oCriteria = new Criteria('workflow');
      $oCriteria->add(TaskPeer::PRO_UID, $sProUid);
      $oDataset = TaskPeer::doSelectRS($oCriteria);
      $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataset->next();
      $oTask = new Task();
      while ($aRow = $oDataset->getRow()) {
        $oCriteria = new Criteria('workflow');
        $oCriteria->add(StepTriggerPeer::TAS_UID, $aRow['TAS_UID']);
        StepTriggerPeer::doDelete($oCriteria);
        if ($oTask->taskExists($aRow['TAS_UID']))
          $oTask->remove($aRow['TAS_UID']);
        $oDataset->next();
      }

    //Delete the dynaforms of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(DynaformPeer::PRO_UID, $sProUid);
    $oDataset = DynaformPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      $sWildcard = PATH_DYNAFORM . $aRow['PRO_UID'] . PATH_SEP . $aRow['DYN_UID'] . '_tmp*';
      foreach( glob($sWildcard) as $fn ) {
        @unlink($fn);
      }
      $sWildcard = PATH_DYNAFORM . $aRow['PRO_UID'] . PATH_SEP . $aRow['DYN_UID'] . '.*';
      foreach( glob($sWildcard) as $fn ) {
        @unlink($fn);
      }
      if ($oDynaform->dynaformExists($aRow['DYN_UID']))
        $oDynaform->remove($aRow['DYN_UID']);
      $oDataset->next();
    }

    //Delete the input documents of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(InputDocumentPeer::PRO_UID, $sProUid);
    $oDataset = InputDocumentPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if ($oInputDocument->InputExists($aRow['INP_DOC_UID']))
        $oInputDocument->remove($aRow['INP_DOC_UID']);
      $oDataset->next();
    }

    //Delete the output documents of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(OutputDocumentPeer::PRO_UID, $sProUid);
    $oDataset = OutputDocumentPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if ($oOutputDocument->OutputExists($aRow['OUT_DOC_UID']))
        $oOutputDocument->remove($aRow['OUT_DOC_UID']);
      $oDataset->next();
    }

    //Delete the steps
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(StepPeer::PRO_UID, $sProUid);
    $oDataset = StepPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      //Delete the steptrigger of process
      /*$oCriteria = new Criteria('workflow');
      $oCriteria->add(StepTriggerPeer::STEP_UID, $aRow['STEP_UID']);
      $oDataseti = StepTriggerPeer::doSelectRS($oCriteria);
      $oDataseti->setFetchmode(ResultSet::FETCHMODE_ASSOC);
      $oDataseti->next();
      while ($aRowi = $oDataseti->getRow()) {
        if ($oStepTrigger->stepTriggerExists($aRowi['STEP_UID'], $aRowi['TAS_UID'], $aRowi['TRI_UID'], $aRowi['ST_TYPE']))
          $oStepTrigger->remove($aRowi['STEP_UID'], $aRowi['TAS_UID'], $aRowi['TRI_UID'], $aRowi['ST_TYPE']);
        $oDataseti->next();
      }*/
      $oStep->remove($aRow['STEP_UID']);
      $oDataset->next();
    }

    //Delete the StepSupervisor
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(StepSupervisorPeer::PRO_UID, $sProUid);
    $oDataset = StepSupervisorPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
        if ($oStep->StepExists($aRow['STEP_UID']))
          $oStep->remove($aRow['STEP_UID']);
        $oDataset->next();
    }

    //Delete the triggers of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(TriggersPeer::PRO_UID, $sProUid);
    $oDataset = TriggersPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if ($oTrigger->TriggerExists($aRow['TRI_UID']))
        $oTrigger->remove($aRow['TRI_UID']);
      $oDataset->next();
    }

    //Delete the routes of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(RoutePeer::PRO_UID, $sProUid);
    $oDataset = RoutePeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if ($oRoute->routeExists($aRow['ROU_UID']))
        $oRoute->remove($aRow['ROU_UID']);
      $oDataset->next();
    }

    //Delete the swimlanes elements of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(SwimlanesElementsPeer::PRO_UID, $sProUid);
    $oDataset = SwimlanesElementsPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if ($oSwimlaneElement->swimlanesElementsExists($aRow['SWI_UID']))
        $oSwimlaneElement->remove($aRow['SWI_UID']);
      $oDataset->next();
    }

    //Delete the DB connections of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(DbSourcePeer::PRO_UID, $sProUid);
    $oDataset = DbSourcePeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if ($oConnection->Exists($aRow['DBS_UID'], $aRow['PRO_UID']))
        $oConnection->remove($aRow['DBS_UID'], $aRow['PRO_UID']);
      $oDataset->next();
    }

    //Delete the sub process of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(SubProcessPeer::PRO_PARENT, $sProUid);
    $oDataset = SubProcessPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if ($oSubProcess->subProcessExists($aRow['SP_UID']))
        $oSubProcess->remove($aRow['SP_UID']);
      $oDataset->next();
    }

    //Delete the caseTracker of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(CaseTrackerPeer::PRO_UID, $sProUid);
    $oDataset = CaseTrackerPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if($oCaseTracker->caseTrackerExists ($aRow['PRO_UID']))
          $oCaseTracker->remove($aRow['PRO_UID']);
      $oDataset->next();
    }

    //Delete the caseTrackerObject of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(CaseTrackerObjectPeer::PRO_UID, $sProUid);
    $oDataset = CaseTrackerObjectPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if($oCaseTrackerObject->caseTrackerObjectExists ($aRow['CTO_UID'])) {
          $oCaseTrackerObject->remove($aRow['CTO_UID']);
      }
      $oDataset->next();
    }

    //Delete the ObjectPermission of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(ObjectPermissionPeer::PRO_UID, $sProUid);
    $oDataset = ObjectPermissionPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
        if($oObjectPermission->Exists ($aRow['OP_UID'])) {
            $oObjectPermission->remove($aRow['OP_UID']);
        }
      $oDataset->next();
    }

    //Delete the Stage of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(StagePeer::PRO_UID, $sProUid);
    $oDataset = StagePeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if($oStage->Exists ($aRow['STG_UID']))
          $oStage->remove($aRow['STG_UID']);
      $oDataset->next();
    }

    //Delete the Event of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(EventPeer::PRO_UID, $sProUid);
    $oDataset = EventPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if($oEvent->Exists ($aRow['EVN_UID']))
          $oEvent->remove($aRow['EVN_UID']);
      $oDataset->next();
    }

    //Delete the CaseScheduler of process
    $oCriteria = new Criteria('workflow');
    $oCriteria->add(CaseSchedulerPeer::PRO_UID, $sProUid);
    $oDataset = CaseSchedulerPeer::doSelectRS($oCriteria);
    $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
    $oDataset->next();
    while ($aRow = $oDataset->getRow()) {
      if($oCaseScheduler->Exists ($aRow['SCH_UID']))
          $oCaseScheduler->remove($aRow['SCH_UID']);
      $oDataset->next();
    }

    return true;
    }
    catch ( Exception $oError) {
      throw($oError);
    }
  }

 /**
  * this function creates a new Process, defined in the object $oData
  * @param string $sProUid
  * @return boolean
  */
  function createProcessFromData ($oData, $pmFilename ) {
    $this->removeProcessRows ($oData->process['PRO_UID'] );
    $this->createProcessRow($oData->process);
    $this->createTaskRows($oData->tasks);
    $aRoutesUID = $this->createRouteRows($oData->routes);
    $this->createLaneRows($oData->lanes);

    /*if(!isset($oData->gateways)){
           //Adding gateway information while importing processes from older version
          //Making compatible with old export process
          $oRoutes = $oData->routes;
          for($i=0;$i<count($oRoutes);$i++){
              $routeUID  = $aRoutesUID[$i];
              $routeType = $oRoutes[$i]['ROU_TYPE'];
              $sTaskUID  = $oRoutes[$i]['TAS_UID'];
              $sNextTask = $oRoutes[$i]['ROU_NEXT_TASK'];
              if($routeType != 'SEQUENTIAL')
              {
                  $oProcessMap = new processMap();
                  $sGatewayUID = $oProcessMap->saveNewGateway($oData->process['PRO_UID'], $sTaskUID, $sNextTask, $routeType );

                  //Updating Route table (GAT_UID column) after inserting Gateway data into GATEWAY table
                  $aData  = array('ROU_UID'=>$routeUID,'GAT_UID'=>$sGatewayUID);
                  $oRoute = new Route();
                  $oRoute->update($aData);
              }
         }
    }
    else*/

    if(isset($oData->gateways))
        $this->createGatewayRows($oData->gateways);

    $this->createDynaformRows($oData->dynaforms);
    $this->createInputRows($oData->inputs);
    $this->createOutputRows($oData->outputs);
    $this->createStepRows($oData->steps);
    $this->createStepSupervisorRows(isset($oData->stepSupervisor) ? $oData->stepSupervisor : array());
    $this->createTriggerRows($oData->triggers);
    $this->createStepTriggerRows($oData->steptriggers);
    $this->createTaskUserRows($oData->taskusers);
    $this->createGroupRow($oData->groupwfs);
    $this->createDBConnectionsRows(isset($oData->dbconnections) ? $oData->dbconnections : array());
    $this->createReportTables(isset($oData->reportTables) ? $oData->reportTables : array(), isset($oData->reportTablesVars) ? $oData->reportTablesVars : array());
    $this->createSubProcessRows(isset($oData->subProcess) ? $oData->subProcess : array());
    $this->createCaseTrackerRows(isset($oData->caseTracker) ? $oData->caseTracker : array());
    $this->createCaseTrackerObjectRows(isset($oData->caseTrackerObject) ? $oData->caseTrackerObject: array());
    $this->createObjectPermissionsRows(isset($oData->objectPermissions) ? $oData->objectPermissions : array());
    $this->createStageRows(isset($oData->stage) ? $oData->stage : array());

    $this->createFieldCondition(isset($oData->fieldCondition) ? $oData->fieldCondition : array(), $oData->dynaforms);
    $this->createEventRows(isset($oData->event) ? $oData->event : array());
    $this->createCaseSchedulerRows(isset($oData->caseScheduler) ? $oData->caseScheduler : array());
    
    //and finally create the files, dynaforms (xml and html), emailTemplates and Public files
    $this->createFiles($oData, $pmFilename);
 }

 /**
  * this function creates a new Process, defined in the object $oData
  * @param string $sProUid
  * @return boolean
  */
  function updateProcessFromData ($oData, $pmFilename ) {
    $this->updateProcessRow ($oData->process );
    $this->removeProcessRows ($oData->process['PRO_UID'] );
    $this->createTaskRows ($oData->tasks );
    $this->createRouteRows ($oData->routes );
    $this->createLaneRows ($oData->lanes );
    $this->createDynaformRows ($oData->dynaforms );
    $this->createInputRows ($oData->inputs );
    $this->createOutputRows ($oData->outputs );
    $this->createStepRows ($oData->steps );
    $this->createStepSupervisorRows($oData->stepSupervisor);
    $this->createTriggerRows ($oData->triggers);
    $this->createStepTriggerRows ($oData->steptriggers);
    $this->createTaskUserRows ($oData->taskusers);
    $this->createGroupRow ($oData->groupwfs );
    $this->createDBConnectionsRows($oData->dbconnections);
    $this->updateReportTables($oData->reportTables, $oData->reportTablesVars);
    $this->createFiles ( $oData, $pmFilename  );
    $this->createSubProcessRows( $oData->subProcess );
    $this->createCaseTrackerRows( $oData->caseTracker);
    $this->createCaseTrackerObjectRows( $oData->caseTrackerObject);
    $this->createObjectPermissionsRows( $oData->objectPermissions);
    $this->createStageRows( $oData->stage);
    $this->createFieldCondition($oData->fieldCondition, $oData->dynaforms);
    $this->createEventRows( $oData->event);
    $this->createCaseSchedulerRows( $oData->caseScheduler );
    
 }

/**
 * get the starting task for a user but from a Tasks object
 * @param $sProUid process uid
 * @param $sUserUid user uid
 * @return an array of tasks
 */
 function getStartingTaskForUser ($sProUid, $sUsrUid ){
    $oTask = new Tasks( );

    return $oTask->getStartingTaskForUser( $sProUid, $sUsrUid );
  }

  /*************************************************
  functions to enable open ProcessMaker Library
  *************************************************/
  /**
   * Open a WebService connection
   * @param $user username for pm
   * @param $pass password for the user
   * @return 1 integer.
   */
  function ws_open ( $user, $pass ) {
    global $sessionId;
    global $client;
    $endpoint = PML_WSDL_URL;
    $sessionId = '';
    $client = new SoapClient( $endpoint );

    $params = array('userid'=>$user, 'password'=>$pass );
    $result = $client->__SoapCall('login', array($params));
    if ( $result->status_code == 0 ) {
      $sessionId = $result->message;
      return 1;
    }
    throw ( new Exception ( $result->message ) );
    return 1;
  }

  /**
   * Open a WebService public connection
   * @param $user username for pm
   * @param $pass password for the user
   * @return 1 integer.
   */
  function ws_open_public ( ) {

    global $sessionId;
    global $client;
    $endpoint = PML_WSDL_URL;
    $sessionId = '';
    ini_set("soap.wsdl_cache_enabled", "0"); // enabling WSDL cache
    try{
    $client = @new SoapClient( $endpoint );
    }catch (Exception $e){
    throw ( new Exception ( $e->message ) );
    }


    return 1;
  }

  /**
   * Consume the processList WebService
   * @return $result process list.
   */
  function ws_processList (  ){
    global $sessionId;
    global $client;

    $endpoint = PML_WSDL_URL;
    $client = new SoapClient( $endpoint );

    $sessionId = '';
    $params = array('sessionId'=>$sessionId );
    $result = $client->__SoapCall('processList', array($params));
    if ( $result->status_code == 0 ) {
      return $result;
    }
    throw ( new Exception ( $result->message ) );
  }

  /**
   * download a File
   * @param  $file file to download
   * @param  $local_path path of the file
   * @param  $newfilename
   * @return $errorMsg process list.
   */
  function downloadFile ($file, $local_path, $newfilename) {
    $err_msg = '';
    $out = fopen($local_path . $newfilename, 'wb');
    if ($out == FALSE){
      throw ( new Exception ("File $newfilename not opened") );
    }

    $ch = curl_init();

    curl_setopt($ch, CURLOPT_FILE, $out);
    curl_setopt($ch, CURLOPT_HEADER, 0);
    curl_setopt($ch, CURLOPT_URL, $file);

    curl_exec($ch);
    $errorMsg = curl_error ( $ch);
    fclose ( $out );

    curl_close($ch);
    return $errorMsg;

  }//end function

  /**
   * get the process Data from a process
   * @param  $proId process Uid
   * @return $result
   */
  function ws_processGetData ( $proId ){
    global $sessionId;
    global $client;

    $endpoint = PML_WSDL_URL;
    $client = new SoapClient( $endpoint );

    $sessionId = '';
    $params = array('sessionId'=>$sessionId , 'processId'=>  $proId);
    $result = $client->__SoapCall('processGetData', array($params));
    if ( $result->status_code == 0 ) {
      return $result;
    }
    throw ( new Exception ( $result->message ) );
  }

  /**
   * parse an array of Items
   * @param  $proId process Uid
   * @return $result
   */
    function parseItemArray( $array ) {
    if (!isset ($array->item) && !is_array($array) ) {
      return null;
    }

    $result = array();
    if ( isset ( $array->item ) ) {
      foreach ($array->item as $key => $value) {
        $result[$value->key] = $value->value;
      }
    }
    else {
      foreach ($array as $key => $value) {
        $result[$value->key] = $value->value;
      }
    }
    return $result;
  }


 }//end class processes

/**
 * Object Document class
 * @package workflow.engine.ProcessMaker
 */
class ObjectDocument{
  public $type;
  public $name;
  public $data;
  public $origin;

  /**
   * Constructor
   */
  function __construct(){
    $this->type = '';
    $this->name = '';
    $this->data = '';
    $this->origin = '';
    }
}

/**
 * ObjectDocument Collection
 * @package workflow.engine.ProcessMaker
 */
class ObjectCellection{
  public $num;
  public $swapc;
  public $objects;

  /**
   * Constructor
   */
  function __construct (){
    $this->objects = Array();
    $this->num = 0;
    $this->swapc = $this->num;
    array_push($this->objects, 'void');
    }

  /**
   * add in the collecetion a new object Document
   * @param $name name object document
   * @param $type type object document
   * @param $data data object document
   * @param $origin origin object document
   * @return void
   */
  function add($name, $type, $data, $origin){
    $o = new ObjectDocument();
    $o->name = $name;
    $o->type = $type;
    $o->data = $data;
    $o->origin = $origin;

    $this->num++;
    array_push($this->objects, $o);
    $this->swapc = $this->num;
    }

  /**
   * get the collection of ObjectDocument 
   * @param $name name object document
   * @param $type type object document
   * @param $data data object document
   * @param $origin origin object document
   * @return void
   */
  function get(){
    if($this->swapc > 0) {
      $e = $this->objects[$this->swapc];
      $this->swapc--;
      return $e;
        } else {
      $this->swapc = $this->num;
      return false;
    }
  }
}