[795] | 1 | <?php |
---|
| 2 | require_once(GALAXIA_LIBRARY.SEP.'src'.SEP.'ProcessManager'.SEP.'BaseManager.php'); |
---|
| 3 | /** |
---|
| 4 | * Adds, removes, modifies and lists processes. |
---|
| 5 | * Most of the methods acts directly in database level, bypassing Project object methods |
---|
[3167] | 6 | * |
---|
[795] | 7 | * @todo Fix multiple non checked fopen ==> infinite loops in case of problems with filesystem |
---|
| 8 | * @package Galaxia |
---|
[3167] | 9 | * @license http://www.gnu.org/copyleft/gpl.html GPL |
---|
[795] | 10 | */ |
---|
| 11 | class ProcessManager extends BaseManager { |
---|
| 12 | |
---|
[3167] | 13 | /** |
---|
| 14 | * @var resource $parser xml parser |
---|
| 15 | * @access public |
---|
| 16 | */ |
---|
| 17 | var $parser; |
---|
[795] | 18 | |
---|
[3167] | 19 | /** |
---|
| 20 | * @var array $tree data struture |
---|
| 21 | * @access public |
---|
| 22 | */ |
---|
| 23 | var $tree; |
---|
[795] | 24 | |
---|
[3167] | 25 | /** |
---|
| 26 | * @var $current current element |
---|
| 27 | * @access public |
---|
| 28 | */ |
---|
| 29 | var $current; |
---|
[795] | 30 | |
---|
[3167] | 31 | /** |
---|
| 32 | * @var $buffer buffer for data |
---|
| 33 | * @access public |
---|
| 34 | */ |
---|
| 35 | var $buffer; |
---|
[795] | 36 | |
---|
[3167] | 37 | /** |
---|
| 38 | * @var object $Process Process |
---|
| 39 | * @access public |
---|
| 40 | */ |
---|
| 41 | var $Process; |
---|
[795] | 42 | |
---|
[3167] | 43 | /** |
---|
| 44 | * @var object $activity_manager Activity Manager |
---|
| 45 | * @access public |
---|
| 46 | */ |
---|
| 47 | var $activity_manager; |
---|
[795] | 48 | |
---|
[3167] | 49 | /** |
---|
| 50 | * @var object $jobManager Job Manager object |
---|
| 51 | * @access public |
---|
| 52 | */ |
---|
| 53 | var $jobManager; |
---|
[795] | 54 | |
---|
[3167] | 55 | /** |
---|
| 56 | * @var object $role_manager Role Manager |
---|
| 57 | * @access public |
---|
| 58 | */ |
---|
| 59 | var $role_manager; |
---|
[795] | 60 | |
---|
[3167] | 61 | /** |
---|
| 62 | * Constructor |
---|
| 63 | * |
---|
| 64 | * @param object &$db ADOdb |
---|
| 65 | * @return object ProcessManager |
---|
| 66 | * @access public |
---|
| 67 | */ |
---|
| 68 | function ProcessManager() |
---|
| 69 | { |
---|
| 70 | parent::BaseManager(); |
---|
| 71 | $this->child_name = 'ProcessManager'; |
---|
| 72 | // $this->activity_manager is not set here to avoid objects loading object A loading object B loading object A, etc |
---|
| 73 | //$this->role_manager will only be loaded when needed as well |
---|
| 74 | } |
---|
[795] | 75 | |
---|
[3167] | 76 | /** |
---|
| 77 | * Collect errors from all linked objects which could have been used by this object. |
---|
| 78 | * Each child class should instantiate this function with her linked objetcs, calling get_error(true) |
---|
| 79 | * |
---|
| 80 | * @param bool $debug False by default, if true debug messages can be added to 'normal' messages |
---|
| 81 | * @param string $prefix Appended to the debug message |
---|
| 82 | * @return void |
---|
| 83 | * @access public |
---|
| 84 | */ |
---|
| 85 | function collect_errors($debug=false, $prefix = '') |
---|
| 86 | { |
---|
| 87 | parent::collect_errors($debug, $prefix); |
---|
| 88 | if (isset($this->activity_manager)) $this->error[] = $this->activity_manager->get_error(false, $debug, $prefix); |
---|
| 89 | if (isset($this->role_manager)) $this->error[] = $this->role_manager->get_error(false, $debug, $prefix); |
---|
| 90 | } |
---|
[795] | 91 | |
---|
[3167] | 92 | /** |
---|
| 93 | * Activates a process |
---|
| 94 | * |
---|
| 95 | * @param int $pId Process id |
---|
| 96 | * @return void |
---|
| 97 | * @access public |
---|
| 98 | */ |
---|
| 99 | function activate_process($pId) |
---|
| 100 | { |
---|
| 101 | $query = 'update '.GALAXIA_TABLE_PREFIX.'processes set wf_is_active=? where wf_p_id=?'; |
---|
| 102 | $this->query($query, array('y',$pId)); |
---|
| 103 | $msg = sprintf(tra('Process %d has been activated'),$pId); |
---|
| 104 | $this->error[] = $msg; |
---|
| 105 | } |
---|
[795] | 106 | |
---|
[3167] | 107 | /** |
---|
| 108 | * Deactivates a process |
---|
| 109 | * |
---|
| 110 | * @param int $pId Process id |
---|
| 111 | * @return void |
---|
| 112 | * @access public |
---|
| 113 | */ |
---|
| 114 | function deactivate_process($pId) |
---|
| 115 | { |
---|
| 116 | $query = 'update '.GALAXIA_TABLE_PREFIX.'processes set wf_is_active=? where wf_p_id=?'; |
---|
| 117 | $this->query($query, array('n',$pId)); |
---|
| 118 | $msg = sprintf(tra('Process %d has been deactivated'),$pId); |
---|
| 119 | $this->error[] = $msg; |
---|
| 120 | } |
---|
[795] | 121 | |
---|
[3167] | 122 | /** |
---|
| 123 | * Creates an XML representation of a process |
---|
| 124 | * |
---|
| 125 | * @param int $pId Process id |
---|
| 126 | * @return string |
---|
| 127 | * @access public |
---|
| 128 | */ |
---|
| 129 | function serialize_process($pId) |
---|
| 130 | { |
---|
| 131 | if (!(isset($this->activity_manager))) $this->activity_manager = &Factory::newInstance('ActivityManager'); |
---|
| 132 | // <process> |
---|
| 133 | $out = '<process>'."\n"; |
---|
| 134 | //we retrieve config values with the others process data |
---|
| 135 | $proc_info =& $this->get_process($pId, true); |
---|
| 136 | $wf_procname = $proc_info['wf_normalized_name']; |
---|
| 137 | $out.= ' <name>'.htmlspecialchars($proc_info['wf_name']).'</name>'."\n"; |
---|
| 138 | $out.= ' <isValid>'.htmlspecialchars($proc_info['wf_is_valid']).'</isValid>'."\n"; |
---|
| 139 | $out.= ' <version>'.htmlspecialchars($proc_info['wf_version']).'</version>'."\n"; |
---|
| 140 | $out.= ' <isActive>'.htmlspecialchars($proc_info['wf_is_active']).'</isActive>'."\n"; |
---|
| 141 | $out.=' <description>'.htmlspecialchars($proc_info['wf_description']).'</description>'."\n"; |
---|
| 142 | $out.= ' <lastModif>'.date("d/m/Y [h:i:s]",$proc_info['wf_last_modif']).'</lastModif>'."\n"; |
---|
[795] | 143 | |
---|
[3167] | 144 | //Shared code |
---|
| 145 | $out.= ' <sharedCode><![CDATA['; |
---|
| 146 | $fp=fopen(GALAXIA_PROCESSES.SEP."$wf_procname".SEP."code".SEP."shared.php","r"); |
---|
| 147 | while(!feof($fp)) { |
---|
| 148 | $line=fread($fp,8192); |
---|
| 149 | $out.=$line; |
---|
| 150 | } |
---|
| 151 | fclose($fp); |
---|
| 152 | $out.= ' ]]></sharedCode>'."\n"; |
---|
[795] | 153 | |
---|
[3167] | 154 | //Loop on config values |
---|
| 155 | $out.=' <configs>'."\n"; |
---|
| 156 | foreach($proc_info['config'] as $res) { |
---|
| 157 | $name = $res['wf_config_name']; |
---|
| 158 | $value_int = $res['wf_config_value_int']; |
---|
| 159 | $value = $res['wf_config_value']; |
---|
| 160 | $out.=' <config>'."\n"; |
---|
| 161 | $out.=' <wf_config_name>'.htmlspecialchars($name).'</wf_config_name>'."\n"; |
---|
| 162 | $out.=' <wf_config_value>'.htmlspecialchars($value).'</wf_config_value>'."\n"; |
---|
| 163 | $out.=' <wf_config_value_int>'.htmlspecialchars($value_int).'</wf_config_value_int>'."\n"; |
---|
| 164 | $out.=' </config>'."\n"; |
---|
| 165 | } |
---|
| 166 | $out.=' </configs>'."\n"; |
---|
[795] | 167 | |
---|
[3167] | 168 | // Now loop over activities |
---|
| 169 | $query = "select * from ".GALAXIA_TABLE_PREFIX."activities where wf_p_id=$pId"; |
---|
| 170 | $result = $this->query($query); |
---|
| 171 | $out.=' <activities>'."\n"; |
---|
| 172 | while($res = $result->fetchRow()) { |
---|
| 173 | $name = $res['wf_normalized_name']; |
---|
| 174 | $out.=' <activity>'."\n"; |
---|
| 175 | $out.=' <name>'.htmlspecialchars($res['wf_name']).'</name>'."\n"; |
---|
| 176 | $out.=' <type>'.htmlspecialchars($res['wf_type']).'</type>'."\n"; |
---|
| 177 | $out.=' <description>'.htmlspecialchars($res['wf_description']).'</description>'."\n"; |
---|
| 178 | $out.=' <lastModif>'.date("d/m/Y [h:i:s]",$res['wf_last_modif']).'</lastModif>'."\n"; |
---|
| 179 | $out.=' <isInteractive>'.$res['wf_is_interactive'].'</isInteractive>'."\n"; |
---|
| 180 | $out.=' <isAutoRouted>'.$res['wf_is_autorouted'].'</isAutoRouted>'."\n"; |
---|
| 181 | $out.=' <roles>'."\n"; |
---|
| 182 | //loop on activity roles |
---|
| 183 | $actid = $res['wf_activity_id']; |
---|
| 184 | $roles =& $this->activity_manager->get_activity_roles($actid); |
---|
| 185 | foreach($roles as $role) { |
---|
| 186 | if ($role['wf_readonly']) |
---|
| 187 | { |
---|
| 188 | $out.=' <role readonly="true">'.htmlspecialchars($role['wf_name']).'</role>'."\n"; |
---|
| 189 | } |
---|
| 190 | else |
---|
| 191 | { |
---|
| 192 | $out.=' <role>'.htmlspecialchars($role['wf_name']).'</role>'."\n"; |
---|
| 193 | } |
---|
| 194 | } |
---|
| 195 | $out.=' </roles>'."\n"; |
---|
| 196 | $out.=' <agents>'."\n"; |
---|
| 197 | //loop on activity agents |
---|
| 198 | $agents =& $this->activity_manager->get_activity_agents($actid); |
---|
| 199 | foreach($agents as $agent) { |
---|
| 200 | $out.=' <agent>'."\n"; |
---|
| 201 | $out.=' <agent_type>'.htmlspecialchars($agent['wf_agent_type']).'</agent_type>'."\n"; |
---|
| 202 | //loop on agent datas |
---|
| 203 | $agent_data =& $this->activity_manager->get_activity_agent_data($actid,$agent['wf_agent_type']); |
---|
| 204 | $out.=' <agent_datas>'."\n"; |
---|
| 205 | foreach($agent_data as $key => $value) |
---|
| 206 | { |
---|
| 207 | if (!($key=='wf_agent_id')) |
---|
| 208 | { |
---|
| 209 | $out.=' <agent_data>'."\n"; |
---|
| 210 | $out.=' <name>'.htmlspecialchars($key).'</name>'."\n"; |
---|
| 211 | $out.=' <value>'.htmlspecialchars($value).'</value>'."\n"; |
---|
| 212 | $out.=' </agent_data>'."\n"; |
---|
| 213 | } |
---|
| 214 | } |
---|
| 215 | $out.=' </agent_datas>'."\n"; |
---|
| 216 | $out.=' </agent>'."\n"; |
---|
| 217 | } |
---|
| 218 | $out.=' </agents>'."\n"; |
---|
[795] | 219 | |
---|
[3167] | 220 | //the code |
---|
| 221 | $out.=' <code><![CDATA['; |
---|
| 222 | $fp=fopen(GALAXIA_PROCESSES.SEP."$wf_procname".SEP."code".SEP."activities".SEP."$name.php","r"); |
---|
| 223 | while(!feof($fp)) { |
---|
| 224 | $line=fread($fp,8192); |
---|
| 225 | $out.=$line; |
---|
| 226 | } |
---|
| 227 | fclose($fp); |
---|
| 228 | $out.=' ]]></code>'; |
---|
| 229 | if($res['wf_is_interactive']=='y') { |
---|
| 230 | $out.=' <template><![CDATA['; |
---|
| 231 | $fp=fopen(GALAXIA_PROCESSES.SEP."$wf_procname".SEP."code".SEP."templates".SEP."$name.tpl","r"); |
---|
| 232 | while(!feof($fp)) { |
---|
| 233 | $line=fread($fp,8192); |
---|
| 234 | $out.=$line; |
---|
| 235 | } |
---|
| 236 | fclose($fp); |
---|
| 237 | $out.=' ]]></template>'; |
---|
| 238 | } |
---|
| 239 | $out.=' </activity>'."\n"; |
---|
| 240 | } |
---|
| 241 | $out.=' </activities>'."\n"; |
---|
| 242 | $out.=' <transitions>'."\n"; |
---|
| 243 | //loop on transitions |
---|
| 244 | $transitions = $this->activity_manager->get_process_transitions($pId); |
---|
| 245 | foreach($transitions as $tran) { |
---|
| 246 | $out.=' <transition>'."\n"; |
---|
| 247 | $out.=' <from>'.htmlspecialchars($tran['wf_act_from_name']).'</from>'."\n"; |
---|
| 248 | $out.=' <to>'.htmlspecialchars($tran['wf_act_to_name']).'</to>'."\n"; |
---|
| 249 | $out.=' </transition>'."\n"; |
---|
| 250 | } |
---|
| 251 | $out.=' </transitions>'."\n"; |
---|
| 252 | $out.= '</process>'."\n"; |
---|
| 253 | //$fp = fopen(GALAXIA_PROCESSES."/$wf_procname/$wf_procname.xml","w"); |
---|
| 254 | //fwrite($fp,$out); |
---|
| 255 | //fclose($fp); |
---|
| 256 | return $out; |
---|
| 257 | } |
---|
[795] | 258 | |
---|
[3167] | 259 | /** |
---|
| 260 | * Creates a process PHP data structure from its XML representation |
---|
| 261 | * |
---|
| 262 | * @param string &$xml XML document |
---|
| 263 | * @return array Process data structure |
---|
| 264 | * @access public |
---|
| 265 | */ |
---|
| 266 | function unserialize_process(&$xml) |
---|
| 267 | { |
---|
| 268 | // Create SAX parser assign this object as base for handlers |
---|
| 269 | // handlers are private methods defined below. |
---|
| 270 | // keep contexts and parse |
---|
| 271 | $this->parser = xml_parser_create(); |
---|
| 272 | xml_parser_set_option($this->parser,XML_OPTION_CASE_FOLDING,0); |
---|
| 273 | //xml_parser_set_option($parser,XML_OPTION_SKIP_WHITE, 1); |
---|
| 274 | xml_set_object($this->parser, $this); |
---|
| 275 | xml_set_element_handler($this->parser, '_start_element_handler', '_end_element_handler'); |
---|
| 276 | xml_set_character_data_handler($this->parser, '_data_handler'); |
---|
| 277 | $aux=Array( |
---|
| 278 | 'name'=>'root', |
---|
| 279 | 'children'=>Array(), |
---|
| 280 | 'parent' => 0, |
---|
| 281 | 'data'=>'', |
---|
| 282 | 'attribs' => Array(), |
---|
| 283 | ); |
---|
| 284 | $this->tree[0]=$aux; |
---|
| 285 | $this->current=0; |
---|
[795] | 286 | |
---|
| 287 | |
---|
[3167] | 288 | if (!xml_parse($this->parser, $xml, true)) { |
---|
| 289 | $error = sprintf("XML error: %s at line %d", |
---|
| 290 | xml_error_string(xml_get_error_code($this->parser)), |
---|
| 291 | xml_get_current_line_number($this->parser)); |
---|
| 292 | trigger_error($error,E_USER_WARNING); |
---|
| 293 | $this->error[] = $error; |
---|
| 294 | } |
---|
| 295 | xml_parser_free($this->parser); |
---|
| 296 | // Now that we have the tree we can do interesting things |
---|
[795] | 297 | |
---|
[3167] | 298 | $process=Array(); |
---|
| 299 | $activities=Array(); |
---|
| 300 | $transitions=Array(); |
---|
| 301 | for($i=0;$i<count($this->tree[1]['children']);$i++) { |
---|
| 302 | // Process attributes |
---|
| 303 | $z=$this->tree[1]['children'][$i]; |
---|
| 304 | $name = trim($this->tree[$z]['name']); |
---|
[795] | 305 | |
---|
[3167] | 306 | //config values |
---|
| 307 | if ($name=='configs') { |
---|
| 308 | for($j=0;$j<count($this->tree[$z]['children']);$j++) { |
---|
| 309 | $z2 = $this->tree[$z]['children'][$j]; |
---|
| 310 | // this is a config $name = $this->tree[$z2]['name']; |
---|
| 311 | $aux = Array(); |
---|
| 312 | if($this->tree[$z2]['name']=='config') { |
---|
| 313 | for($k=0;$k<count($this->tree[$z2]['children']);$k++) { |
---|
| 314 | $z3 = $this->tree[$z2]['children'][$k]; |
---|
| 315 | $name = trim($this->tree[$z3]['name']); |
---|
| 316 | $value= trim($this->tree[$z3]['data']); |
---|
| 317 | $aux[$name]=$value; |
---|
| 318 | } |
---|
| 319 | $configs[]=$aux; |
---|
| 320 | } |
---|
| 321 | } |
---|
| 322 | } |
---|
| 323 | //activities |
---|
| 324 | elseif($name=='activities') { |
---|
| 325 | for($j=0;$j<count($this->tree[$z]['children']);$j++) { |
---|
| 326 | $z2 = $this->tree[$z]['children'][$j]; |
---|
| 327 | // this is an activity $name = $this->tree[$z2]['name']; |
---|
| 328 | $aux = Array(); |
---|
| 329 | if($this->tree[$z2]['name']=='activity') { |
---|
| 330 | for($k=0;$k<count($this->tree[$z2]['children']);$k++) { |
---|
| 331 | $z3 = $this->curre[$z2]['children'][$k]; |
---|
| 332 | $name = trim($this->tree[$z3]['name']); |
---|
| 333 | $value= trim($this->tree[$z3]['data']); |
---|
| 334 | if($name=='roles') { |
---|
| 335 | $roles=Array(); |
---|
| 336 | for($l=0;$l<count($this->tree[$z3]['children']);$l++) { |
---|
| 337 | $z4 = $this->tree[$z3]['children'][$l]; |
---|
| 338 | $name = trim($this->tree[$z4]['name']); |
---|
| 339 | $data = trim($this->tree[$z4]['data']); |
---|
| 340 | $attribs = $this->tree[$z4]['attribs']; |
---|
| 341 | $readonly = false; |
---|
| 342 | if ( (isset($attribs['readonly'])) && ($attribs['readonly'])) |
---|
| 343 | { |
---|
| 344 | //role in read-only |
---|
| 345 | $readonly = true; |
---|
| 346 | } |
---|
| 347 | $roles[]=array( |
---|
| 348 | 'name' => $data, |
---|
| 349 | 'readonly' => $readonly, |
---|
| 350 | ); |
---|
| 351 | } |
---|
| 352 | } |
---|
| 353 | elseif ($name=='agents') |
---|
| 354 | { |
---|
| 355 | $agents=Array(); |
---|
| 356 | for($l=0;$l<count($this->tree[$z3]['children']);$l++) |
---|
| 357 | { |
---|
| 358 | $z4 = $this->tree[$z3]['children'][$l]; |
---|
| 359 | //$name is agent |
---|
| 360 | $name = trim($this->tree[$z4]['name']); |
---|
| 361 | if ($name = 'agent') |
---|
| 362 | { |
---|
| 363 | $agent = array(); |
---|
| 364 | for($m=0;$m<count($this->tree[$z4]['children']);$m++) |
---|
| 365 | { |
---|
| 366 | $z5 = $this->tree[$z4]['children'][$m]; |
---|
| 367 | //$name is agent_type or agent_datas |
---|
| 368 | $name = trim($this->tree[$z5]['name']); |
---|
| 369 | // data will be the agent_type or an array for agent_datas |
---|
| 370 | $data = trim($this->tree[$z5]['data']); |
---|
| 371 | if ($name=='agent_type') |
---|
| 372 | { |
---|
| 373 | $agent['wf_agent_type']=$data; |
---|
| 374 | } |
---|
| 375 | elseif ($name=='agent_datas') |
---|
| 376 | { |
---|
| 377 | for($n=0;$n<count($this->tree[$z5]['children']);$n++) |
---|
| 378 | { |
---|
| 379 | $z6 = $this->tree[$z5]['children'][$n]; |
---|
| 380 | //$name is agent_data $val is an array |
---|
| 381 | $name = trim($this->tree[$z6]['name']); |
---|
| 382 | $val = trim($this->tree[$z6]['data']); |
---|
| 383 | if ($name=='agent_data') |
---|
| 384 | { |
---|
| 385 | for($o=0;$o<count($this->tree[$z6]['children']);$o++) |
---|
| 386 | { |
---|
| 387 | $z7 = $this->tree[$z6]['children'][$o]; |
---|
| 388 | //$name is agent_data $val is 'name' or 'value' |
---|
| 389 | $name = trim($this->tree[$z7]['name']); |
---|
| 390 | $content = trim($this->tree[$z7]['data']); |
---|
| 391 | //echo "<br>z7 name $name content: $content"; |
---|
| 392 | if ($name=='name') |
---|
| 393 | { |
---|
| 394 | $agent_data_name = $content; |
---|
| 395 | } |
---|
| 396 | elseif ($name=='value') |
---|
| 397 | { |
---|
| 398 | $agent_data_value =& $content; |
---|
| 399 | } |
---|
| 400 | } |
---|
| 401 | //echo "<br>associate $agent_data_name to $agent_data_value <hr>"; |
---|
| 402 | $agent[$agent_data_name] = $agent_data_value; |
---|
| 403 | } |
---|
| 404 | } |
---|
| 405 | } |
---|
| 406 | } |
---|
| 407 | $agents[]=$agent; |
---|
| 408 | } |
---|
| 409 | } |
---|
| 410 | } else { |
---|
| 411 | $aux[$name]=$value; |
---|
| 412 | //print("$name:$value<br/>"); |
---|
| 413 | } |
---|
| 414 | } |
---|
| 415 | $aux['agents']=$agents; |
---|
| 416 | $aux['roles']=$roles; |
---|
| 417 | $activities[]=$aux; |
---|
| 418 | } |
---|
| 419 | } |
---|
| 420 | } elseif($name=='transitions') { |
---|
| 421 | for($j=0;$j<count($this->tree[$z]['children']);$j++) { |
---|
| 422 | $z2 = $this->tree[$z]['children'][$j]; |
---|
| 423 | // this is an activity $name = $this->tree[$z2]['name']; |
---|
| 424 | $aux=Array(); |
---|
| 425 | if($this->tree[$z2]['name']=='transition') { |
---|
| 426 | for($k=0;$k<count($this->tree[$z2]['children']);$k++) { |
---|
| 427 | $z3 = $this->tree[$z2]['children'][$k]; |
---|
| 428 | $name = trim($this->tree[$z3]['name']); |
---|
| 429 | $value= trim($this->tree[$z3]['data']); |
---|
| 430 | if($name == 'from' || $name == 'to') { |
---|
| 431 | $aux[$name]=$value; |
---|
| 432 | } |
---|
| 433 | } |
---|
| 434 | } |
---|
| 435 | $transitions[] = $aux; |
---|
| 436 | } |
---|
| 437 | } else { |
---|
| 438 | $value = trim($this->tree[$z]['data']); |
---|
| 439 | //print("$name is $value<br/>"); |
---|
| 440 | $process[$name]=$value; |
---|
| 441 | } |
---|
| 442 | } |
---|
| 443 | $process['configs']=$configs; |
---|
| 444 | $process['activities']=$activities; |
---|
| 445 | $process['transitions']=$transitions; |
---|
| 446 | return $process; |
---|
| 447 | } |
---|
[795] | 448 | |
---|
[3167] | 449 | /** |
---|
| 450 | * Creates a process from the process data structure, if you want to convert an XML to a process then use first unserialize_process and then this method. |
---|
| 451 | * |
---|
| 452 | * @access public |
---|
| 453 | * @param string &$data |
---|
| 454 | * @return bool |
---|
| 455 | */ |
---|
| 456 | function import_process(&$data) |
---|
| 457 | { |
---|
| 458 | //Now the show begins |
---|
| 459 | if (!(isset($this->activity_manager))) $this->activity_manager = &Factory::newInstance('ActivityManager'); |
---|
| 460 | if (!(isset($this->role_manager))) $this->role_manager = &Factory::newInstance('RoleManager'); |
---|
| 461 | if (!isset($this->jobManager)) |
---|
| 462 | $this->jobManager = &Factory::newInstance('JobManager'); |
---|
| 463 | |
---|
| 464 | // First create the process. Always inactive and inactive first. |
---|
| 465 | $vars = Array( |
---|
| 466 | 'wf_name' => trim($data['name']), |
---|
| 467 | 'wf_version' => $data['version'], |
---|
| 468 | 'wf_description' => $data['description'], |
---|
| 469 | 'wf_last_modif' => $data['lastModif'], |
---|
| 470 | 'wf_is_active' => false, |
---|
| 471 | 'wf_is_valid' => false, |
---|
| 472 | 'config' => $data['configs'], |
---|
| 473 | ); |
---|
| 474 | |
---|
| 475 | if (empty($vars['wf_name'])) |
---|
| 476 | { |
---|
| 477 | $msg = tra('invalid name specified'); |
---|
| 478 | $this->error[] = $msg; |
---|
| 479 | return false; |
---|
| 480 | } |
---|
| 481 | |
---|
[5921] | 482 | if (preg_match('/^[0-9]{1,2}\.[0-9]{1,2}$/', $vars['wf_version']) === false) |
---|
[3167] | 483 | { |
---|
| 484 | $msg = tra('invalid version specified'); |
---|
| 485 | $this->error[] = $msg; |
---|
| 486 | return false; |
---|
| 487 | } |
---|
| 488 | |
---|
| 489 | if ($this->process_name_exists($vars['wf_name'], $vars['wf_version'])) |
---|
| 490 | { |
---|
| 491 | $msg = sprintf(tra('Process %s %s already exists, the import process was aborted'),$vars['wf_name'],$vars['wf_version']); |
---|
| 492 | $this->error[] = $msg; |
---|
| 493 | return false; |
---|
| 494 | } |
---|
| 495 | $pid = $this->replace_process(0,$vars,false); |
---|
| 496 | //Put the shared code |
---|
| 497 | $proc_info = $this->get_process($pid); |
---|
| 498 | $wf_procname = $proc_info['wf_normalized_name']; |
---|
| 499 | $fp = fopen(GALAXIA_PROCESSES.SEP.$wf_procname.SEP.'code'.SEP.'shared.php',"w"); |
---|
| 500 | fwrite($fp, $data['sharedCode']); |
---|
| 501 | fclose($fp); |
---|
| 502 | $actids = Array(); |
---|
| 503 | |
---|
| 504 | // Foreach activity create activities |
---|
| 505 | foreach($data['activities'] as $activity) { |
---|
| 506 | |
---|
| 507 | $vars = Array( |
---|
| 508 | 'wf_name' => $activity['name'], |
---|
| 509 | 'wf_description' => $activity['description'], |
---|
| 510 | 'wf_type' => $activity['type'], |
---|
| 511 | 'wf_menu_path' => $activity['menuPath'], |
---|
| 512 | 'wf_last_modif' => $activity['lastModif'], |
---|
| 513 | 'wf_is_interactive' => $activity['isInteractive'], |
---|
| 514 | 'wf_is_autorouted' => $activity['isAutoRouted'] |
---|
| 515 | ); |
---|
| 516 | $actname=$this->activity_manager->_normalize_name($activity['name']); |
---|
| 517 | $actid = $this->activity_manager->replace_activity($pid,0,$vars); |
---|
| 518 | |
---|
| 519 | $fp = fopen(GALAXIA_PROCESSES.SEP.$wf_procname.SEP.'code'.SEP.'activities'.SEP.$actname.'.php',"w"); |
---|
| 520 | fwrite($fp, $activity['code']); |
---|
| 521 | fclose($fp); |
---|
| 522 | if($activity['isInteractive']=='y') { |
---|
| 523 | $fp = fopen(GALAXIA_PROCESSES.SEP.$wf_procname.SEP.'code'.SEP.'templates'.SEP.$actname.'.tpl',"w"); |
---|
| 524 | fwrite($fp,$activity['template']); |
---|
| 525 | fclose($fp); |
---|
| 526 | } |
---|
| 527 | $actids[$activity['name']] = $this->activity_manager->_get_activity_id_by_name($pid, $activity['name']); |
---|
| 528 | $actname = $this->activity_manager->_normalize_name($activity['name']); |
---|
| 529 | $now = date("U"); |
---|
| 530 | //roles |
---|
| 531 | if( is_array($activity['roles']) && count($activity['roles']) > 0 ) |
---|
| 532 | { |
---|
| 533 | foreach($activity['roles'] as $role) |
---|
| 534 | { |
---|
| 535 | $rolename = $role['name']; |
---|
| 536 | $vars = Array( |
---|
| 537 | 'wf_name' => $rolename, |
---|
| 538 | 'wf_description' => $rolename, |
---|
| 539 | 'wf_last_modif' => $now, |
---|
| 540 | ); |
---|
| 541 | if(!$this->role_manager->role_name_exists($pid,$rolename)) { |
---|
| 542 | $rid=$this->role_manager->replace_role($pid,0,$vars); |
---|
| 543 | } else { |
---|
| 544 | $rid = $this->role_manager->get_role_id($pid,$rolename); |
---|
| 545 | } |
---|
| 546 | if($actid && $rid) { |
---|
| 547 | $this->activity_manager->add_activity_role($actid,$rid,$role['readonly']); |
---|
| 548 | } |
---|
| 549 | } |
---|
| 550 | } |
---|
| 551 | //agents |
---|
| 552 | if( is_array($activity['agents']) && count($activity['agents']) > 0 ) |
---|
| 553 | { |
---|
| 554 | foreach($activity['agents'] as $agent) |
---|
| 555 | { |
---|
| 556 | if (empty($agent['wf_agent_type'])) |
---|
| 557 | { |
---|
| 558 | $this->error[] = lang('empty agent type'); |
---|
| 559 | } |
---|
| 560 | else |
---|
| 561 | { |
---|
| 562 | //create a new agent of the same type for the new activity |
---|
| 563 | $agentid = $this->activity_manager->add_activity_agent($actid,$agent['wf_agent_type']); |
---|
| 564 | //save values of this new agent |
---|
| 565 | $bindvars = Array(); |
---|
| 566 | $query = 'update '.GALAXIA_TABLE_PREFIX.'agent_'.$agent['wf_agent_type'].' |
---|
| 567 | set '; |
---|
| 568 | //we wont need the old type anymore |
---|
| 569 | unset($agent['wf_agent_type']); |
---|
| 570 | $countfields = 0; |
---|
| 571 | foreach ($agent as $key => $value) |
---|
| 572 | { |
---|
| 573 | if ($key) |
---|
| 574 | { |
---|
| 575 | $countfields++; |
---|
| 576 | $query .= "$key = ? ,"; |
---|
| 577 | $bindvars[] = $value; |
---|
| 578 | } |
---|
| 579 | } |
---|
| 580 | $query = substr($query,'0',-1); |
---|
| 581 | $query .= ' where wf_agent_id = ?'; |
---|
| 582 | $bindvars[] = $agentid; |
---|
| 583 | if ($countfields) $this->query($query, $bindvars); |
---|
| 584 | } |
---|
| 585 | } |
---|
| 586 | } |
---|
| 587 | } |
---|
| 588 | //transitions |
---|
| 589 | foreach($data['transitions'] as $tran) |
---|
| 590 | { |
---|
| 591 | $this->activity_manager->add_transition($pid,$actids[$tran['from']],$actids[$tran['to']]); |
---|
| 592 | } |
---|
| 593 | |
---|
| 594 | foreach ($data['jobs'] as $job) |
---|
| 595 | { |
---|
| 596 | $this->jobManager->replaceJob($pid, 0, $job); |
---|
| 597 | } |
---|
| 598 | |
---|
| 599 | // create a graph for the new process |
---|
| 600 | $this->activity_manager->build_process_graph($pid); |
---|
| 601 | //Test the final process |
---|
| 602 | $this->activity_manager->validate_process_activities($pid); |
---|
| 603 | |
---|
| 604 | $msg = sprintf(tra('Process %s %s imported'),$proc_info['wf_name'],$proc_info['wf_version']); |
---|
| 605 | $this->error[] = $msg; |
---|
| 606 | return true; |
---|
| 607 | } |
---|
| 608 | |
---|
| 609 | /** |
---|
| 610 | * Creates a new process based on an existing process changing the process version. |
---|
| 611 | * By default the process is created as an unactive process and the version is by default a minor version of the process |
---|
| 612 | * |
---|
| 613 | * @param int $pId Process id |
---|
| 614 | * @param bool $minor Process previous version |
---|
| 615 | * @return int Process id |
---|
| 616 | * @access public |
---|
| 617 | */ |
---|
| 618 | function new_process_version($pId, $minor=true) |
---|
| 619 | { |
---|
| 620 | if (!(isset($this->activity_manager))) $this->activity_manager = &Factory::newInstance('ActivityManager'); |
---|
| 621 | $oldpid = $pId; |
---|
| 622 | //retrieve process info with config rows |
---|
| 623 | $proc_info = $this->get_process($pId, true); |
---|
| 624 | if(!($proc_info) || (count($proc_info)==0)) return false; |
---|
| 625 | $name = $proc_info['wf_name']; |
---|
| 626 | |
---|
| 627 | // Now update the version |
---|
| 628 | $version = $this->_new_version($proc_info['wf_version'],$minor); |
---|
| 629 | while($this->getOne('select count(*) from '.GALAXIA_TABLE_PREFIX.'processes where wf_name=? and wf_version=?',array($name,$version))) |
---|
| 630 | { |
---|
| 631 | $version = $this->_new_version($version,$minor); |
---|
| 632 | } |
---|
| 633 | $oldname = $proc_info['wf_normalized_name']; |
---|
| 634 | |
---|
| 635 | // Make new versions unactive |
---|
| 636 | $proc_info['wf_version'] = $version; |
---|
| 637 | $proc_info['wf_is_active'] = 'n'; |
---|
| 638 | // create a new process, but don't create start/end activities |
---|
| 639 | $pid = $this->replace_process(0, $proc_info, false); |
---|
| 640 | if (!pid) return false; |
---|
| 641 | |
---|
| 642 | //Since we are copying a process we should copy |
---|
| 643 | //the old directory structure to the new directory |
---|
| 644 | //oldname was saved a few lines before |
---|
| 645 | $newname = $this->_get_normalized_name($pid); |
---|
| 646 | $this->_rec_copy(GALAXIA_PROCESSES.SEP.$oldname.SEP.'code',GALAXIA_PROCESSES.SEP.$newname.SEP.'code'); |
---|
| 647 | // And here copy all the activities & so |
---|
| 648 | $query = 'select * from '.GALAXIA_TABLE_PREFIX.'activities where wf_p_id=?'; |
---|
| 649 | $result = $this->query($query, array($oldpid)); |
---|
| 650 | $newaid = array(); |
---|
| 651 | while($res = $result->fetchRow()) { |
---|
| 652 | $oldaid = $res['wf_activity_id']; |
---|
| 653 | // the false tell the am not to create activities source files |
---|
| 654 | $newaid[$oldaid] = $this->activity_manager->replace_activity($pid,0,$res, false); |
---|
| 655 | } |
---|
| 656 | // create transitions |
---|
| 657 | $query = 'select * from '.GALAXIA_TABLE_PREFIX.'transitions where wf_p_id=?'; |
---|
| 658 | $result = $this->query($query, array($oldpid)); |
---|
| 659 | |
---|
| 660 | /* create the jobs */ |
---|
| 661 | $query = "INSERT INTO " . GALAXIA_TABLE_PREFIX . "jobs (wf_process_id, name, description, time_start, interval_value, interval_unity, date_type, week_days, month_offset, active) (SELECT {$pid}, name, description, time_start, interval_value, interval_unity, date_type, week_days, month_offset, FALSE FROM " . GALAXIA_TABLE_PREFIX . "jobs WHERE wf_process_id = ?)"; |
---|
| 662 | $this->query($query, array($oldpid)); |
---|
| 663 | |
---|
| 664 | while($res = $result->fetchRow()) { |
---|
| 665 | if (empty($newaid[$res['wf_act_from_id']]) || empty($newaid[$res['wf_act_to_id']])) { |
---|
| 666 | continue; |
---|
| 667 | } |
---|
| 668 | $this->activity_manager->add_transition($pid,$newaid[$res['wf_act_from_id']],$newaid[$res['wf_act_to_id']]); |
---|
| 669 | } |
---|
| 670 | // create roles |
---|
| 671 | if (!(isset($this->role_manager))) $this->role_manager = &Factory::newInstance('RoleManager'); |
---|
| 672 | $query = 'select * from '.GALAXIA_TABLE_PREFIX.'roles where wf_p_id=?'; |
---|
| 673 | $result = $this->query($query, array($oldpid)); |
---|
| 674 | $newrid = array(); |
---|
| 675 | while($res = $result->fetchRow()) { |
---|
| 676 | if(!$this->role_manager->role_name_exists($pid,$res['wf_name'])) { |
---|
| 677 | $rid=$this->role_manager->replace_role($pid,0,$res); |
---|
| 678 | } else { |
---|
| 679 | $rid = $this->role_manager->get_role_id($pid,$res['wf_name']); |
---|
| 680 | } |
---|
| 681 | $newrid[$res['wf_role_id']] = $rid; |
---|
| 682 | } |
---|
| 683 | // map users to roles |
---|
| 684 | if (count($newrid) > 0) { |
---|
| 685 | $query = 'select * from '.GALAXIA_TABLE_PREFIX.'user_roles where wf_p_id=?'; |
---|
| 686 | $result = $this->query($query, array($oldpid)); |
---|
| 687 | while($res = $result->fetchRow()) { |
---|
| 688 | if (empty($newrid[$res['wf_role_id']])) { |
---|
| 689 | continue; |
---|
| 690 | } |
---|
| 691 | $this->role_manager->map_user_to_role($pid,$res['wf_user'],$newrid[$res['wf_role_id']], $res['wf_account_type']); |
---|
| 692 | } |
---|
| 693 | } |
---|
| 694 | // add roles to activities |
---|
| 695 | if (count($newaid) > 0 && count($newrid ) > 0) { |
---|
| 696 | $query = 'select * from '.GALAXIA_TABLE_PREFIX.'activity_roles where wf_activity_id in (' . join(', ',array_keys($newaid)) . ')'; |
---|
| 697 | $result = $this->query($query); |
---|
| 698 | while($res = $result->fetchRow()) { |
---|
| 699 | if (empty($newaid[$res['wf_activity_id']]) || empty($newrid[$res['wf_role_id']])) { |
---|
| 700 | continue; |
---|
| 701 | } |
---|
| 702 | $this->activity_manager->add_activity_role($newaid[$res['wf_activity_id']],$newrid[$res['wf_role_id']], $res['wf_readonly']); |
---|
| 703 | } |
---|
| 704 | } |
---|
| 705 | |
---|
| 706 | //create agents |
---|
| 707 | //get the list of agents used by the old process |
---|
| 708 | $query = 'select gaa.* from '.GALAXIA_TABLE_PREFIX.'activity_agents gaa |
---|
| 709 | INNER JOIN '.GALAXIA_TABLE_PREFIX.'activities gac ON gaa.wf_activity_id = gac.wf_activity_id |
---|
| 710 | where gac.wf_p_id=?'; |
---|
| 711 | $result = $this->query($query, array($oldpid)); |
---|
| 712 | if (!(empty($result))) |
---|
| 713 | { |
---|
| 714 | while ($res = $result->fetchRow()) |
---|
| 715 | { |
---|
| 716 | //create a new agent of the same type for the new activity |
---|
| 717 | $agentid = $this->activity_manager->add_activity_agent($newaid[$res['wf_activity_id']],$res['wf_agent_type']); |
---|
| 718 | //save values of this new agents, taking the old ones, we make a simple copy |
---|
| 719 | $old_activity_agent_data =& $this->activity_manager->get_activity_agent_data($res['wf_activity_id'],$res['wf_agent_type']); |
---|
| 720 | //we wont need the old id and type |
---|
| 721 | unset($old_activity_agent_data['wf_agent_id']); |
---|
| 722 | unset($old_activity_agent_data['wf_agent_type']); |
---|
| 723 | $bindvars = Array(); |
---|
| 724 | $query = 'update '.GALAXIA_TABLE_PREFIX.'agent_'.$res['wf_agent_type'].' |
---|
| 725 | set '; |
---|
| 726 | $countfields = 0; |
---|
| 727 | foreach ($old_activity_agent_data as $key => $value) |
---|
| 728 | { |
---|
| 729 | if ($key) |
---|
| 730 | { |
---|
| 731 | $countfields++; |
---|
| 732 | $query .= "$key = ? ,"; |
---|
| 733 | $bindvars[] = $value; |
---|
| 734 | } |
---|
| 735 | } |
---|
| 736 | $query = substr($query,'0',-1); |
---|
| 737 | $query .= ' where wf_agent_id = ?'; |
---|
| 738 | $bindvars[] = $agentid; |
---|
| 739 | if ($countfields) $this->query($query, $bindvars); |
---|
| 740 | } |
---|
| 741 | } |
---|
| 742 | |
---|
| 743 | // create a graph for the new process |
---|
| 744 | $this->activity_manager->build_process_graph($pid); |
---|
| 745 | |
---|
| 746 | return $pid; |
---|
| 747 | } |
---|
| 748 | |
---|
| 749 | /** |
---|
| 750 | * This function can be used to check if a process name exists, note that this is NOT used by replace_process since that function can be used to |
---|
| 751 | * create new versions of an existing process. The application must use this method to ensure that processes have unique names. |
---|
| 752 | * |
---|
| 753 | * @param string $name Process name |
---|
| 754 | * @param string $version Process version |
---|
| 755 | * @return bool |
---|
| 756 | * @access public |
---|
| 757 | */ |
---|
| 758 | function process_name_exists($name,$version) |
---|
| 759 | { |
---|
| 760 | $name = addslashes($this->_normalize_name($name,$version)); |
---|
| 761 | return $this->getOne('select count(*) from '.GALAXIA_TABLE_PREFIX.'processes where wf_normalized_name=?',array($name)); |
---|
| 762 | } |
---|
| 763 | |
---|
| 764 | |
---|
| 765 | /** |
---|
| 766 | * Gets a process by pId. Fields are returned as an associative array. |
---|
| 767 | * If withConfig is set (false by default), the configuration options are returned as well the ['config'] key is then an array containing the config data with type distinction |
---|
| 768 | * |
---|
| 769 | * @param int $pId Process id |
---|
| 770 | * @param bool $withConfig Configuration options |
---|
| 771 | * @return bool |
---|
| 772 | * @access public |
---|
| 773 | */ |
---|
| 774 | function get_process($pId, $withConfig=false) |
---|
| 775 | { |
---|
| 776 | $query = 'select * from '.GALAXIA_TABLE_PREFIX.'processes where wf_p_id=?'; |
---|
| 777 | $result = $this->query($query, array($pId)); |
---|
| 778 | if((empty($result)) || (!$result->numRows())) return false; |
---|
| 779 | $res = $result->fetchRow(); |
---|
| 780 | if ($withConfig) |
---|
| 781 | { |
---|
| 782 | // by setting true we force this function to keep type distinction on config values |
---|
| 783 | $res['config'] = $this->getConfigValues($res['wf_p_id'], true); |
---|
| 784 | } |
---|
| 785 | return $res; |
---|
| 786 | } |
---|
| 787 | |
---|
| 788 | /** |
---|
| 789 | * Lists all processes |
---|
| 790 | * |
---|
| 791 | * @param int $offset Resultset starting row |
---|
| 792 | * @param int $maxRecords Max number of resulting rows |
---|
| 793 | * @param string $sort_mode Sorting mode |
---|
| 794 | * @param string $find Search query string |
---|
| 795 | * @param string $where Condition query string |
---|
| 796 | * @return bool |
---|
| 797 | * @access public |
---|
| 798 | */ |
---|
| 799 | function list_processes($offset,$maxRecords,$sort_mode,$find='',$where='') |
---|
| 800 | { |
---|
[4740] | 801 | if(!empty($sort_mode)) |
---|
| 802 | $sort_mode = $this->convert_sortmode($sort_mode); |
---|
[3167] | 803 | if($find) { |
---|
| 804 | $findesc = '%'.$find.'%'; |
---|
| 805 | $mid=' where ((wf_name like ?) or (wf_description like ?))'; |
---|
| 806 | $bindvars = array($findesc,$findesc); |
---|
| 807 | } else { |
---|
| 808 | $mid=''; |
---|
| 809 | $bindvars = array(); |
---|
| 810 | } |
---|
| 811 | if($where) { |
---|
| 812 | if($mid) { |
---|
| 813 | $mid.= " and ($where) "; |
---|
| 814 | } else { |
---|
| 815 | $mid.= " where ($where) "; |
---|
| 816 | } |
---|
| 817 | } |
---|
| 818 | $query = 'select * from '.GALAXIA_TABLE_PREFIX."processes $mid"; |
---|
| 819 | $query_cant = 'select count(*) from '.GALAXIA_TABLE_PREFIX."processes $mid"; |
---|
| 820 | $result = $this->query($query,$bindvars,$maxRecords,$offset, true, $sort_mode); |
---|
| 821 | $cant = $this->getOne($query_cant,$bindvars); |
---|
| 822 | $ret = Array(); |
---|
| 823 | if (isset($result)) |
---|
| 824 | { |
---|
| 825 | while($res = $result->fetchRow()) |
---|
| 826 | { |
---|
| 827 | $ret[] = $res; |
---|
| 828 | } |
---|
| 829 | } |
---|
| 830 | $retval = Array(); |
---|
| 831 | $retval['data'] = $ret; |
---|
| 832 | $retval['cant'] = $cant; |
---|
| 833 | return $retval; |
---|
| 834 | } |
---|
| 835 | |
---|
[795] | 836 | /*! |
---|
| 837 | Marks a process as an invalid process |
---|
| 838 | */ |
---|
[3167] | 839 | function invalidate_process($pid) |
---|
| 840 | { |
---|
| 841 | $query = 'update '.GALAXIA_TABLE_PREFIX.'processes set wf_is_valid=? where wf_p_id=?'; |
---|
| 842 | $this->query($query, array('n',$pid)); |
---|
| 843 | } |
---|
[795] | 844 | |
---|
[3167] | 845 | /** |
---|
| 846 | * Removes a process by pId |
---|
| 847 | * |
---|
| 848 | * @param int $pId Process id |
---|
| 849 | * @return bool |
---|
| 850 | * @access public |
---|
| 851 | */ |
---|
| 852 | function remove_process($pId) |
---|
| 853 | { |
---|
| 854 | if (!(isset($this->activity_manager))) $this->activity_manager = &Factory::newInstance('ActivityManager'); |
---|
| 855 | if (!isset($this->jobManager)) |
---|
| 856 | $this->jobManager = &Factory::newInstance('JobManager'); |
---|
| 857 | $this->deactivate_process($pId); |
---|
| 858 | $name = $this->_get_normalized_name($pId); |
---|
[795] | 859 | |
---|
[3167] | 860 | // start a transaction |
---|
| 861 | $this->db->StartTrans(); |
---|
| 862 | $this->jobManager->removeJobsByProcessID($pId); |
---|
| 863 | |
---|
| 864 | // Remove process activities |
---|
| 865 | $query = 'select wf_activity_id from '.GALAXIA_TABLE_PREFIX.'activities where wf_p_id=?'; |
---|
| 866 | $result = $this->query($query, array($pId)); |
---|
| 867 | while($res = $result->fetchRow()) { |
---|
| 868 | //we add a false parameter to prevent the ActivityManager from opening a new transaction |
---|
| 869 | $this->activity_manager->remove_activity($pId,$res['wf_activity_id'], false); |
---|
| 870 | } |
---|
| 871 | |
---|
| 872 | // Remove process roles |
---|
| 873 | $query = 'delete from '.GALAXIA_TABLE_PREFIX.'roles where wf_p_id=?'; |
---|
| 874 | $this->query($query, array($pId)); |
---|
| 875 | $query = 'delete from '.GALAXIA_TABLE_PREFIX.'user_roles where wf_p_id=?'; |
---|
| 876 | $this->query($query, array($pId)); |
---|
| 877 | |
---|
| 878 | // Remove process instances |
---|
| 879 | $query = 'delete from '.GALAXIA_TABLE_PREFIX.'instances where wf_p_id=?'; |
---|
| 880 | $this->query($query, array($pId)); |
---|
| 881 | |
---|
| 882 | // Remove the directory structure |
---|
| 883 | if (!empty($name) && is_dir(GALAXIA_PROCESSES.SEP.$name)) { |
---|
| 884 | $this->_remove_directory(GALAXIA_PROCESSES.SEP.$name,true); |
---|
| 885 | } |
---|
| 886 | if (GALAXIA_TEMPLATES && !empty($name) && is_dir(GALAXIA_TEMPLATES.SEP.$name)) { |
---|
| 887 | $this->_remove_directory(GALAXIA_TEMPLATES.SEP.$name,true); |
---|
| 888 | } |
---|
| 889 | |
---|
| 890 | // Remove configuration data |
---|
| 891 | $query = 'delete from '.GALAXIA_TABLE_PREFIX.'process_config where wf_p_id=?'; |
---|
| 892 | $this->query($query, array($pId)); |
---|
| 893 | |
---|
| 894 | // And finally remove the proc |
---|
| 895 | $query = 'delete from '.GALAXIA_TABLE_PREFIX.'processes where wf_p_id=?'; |
---|
| 896 | $this->query($query, array($pId)); |
---|
| 897 | $msg = sprintf(tra('Process %s removed'),$name); |
---|
| 898 | $this->error[] = $msg; |
---|
| 899 | |
---|
| 900 | // perform commit (return true) or Rollback (return false) |
---|
| 901 | return $this->db->CompleteTrans(); |
---|
| 902 | |
---|
| 903 | } |
---|
| 904 | |
---|
| 905 | /** |
---|
| 906 | * Updates or inserts a new process in the database, $vars is an associative array containing the fields to update or to insert as needed. |
---|
| 907 | * Configuration options should be in an array associated with the 'config' key |
---|
| 908 | * this config array should contain 'wf_config_name', 'wf_config_value' and 'wf_config_value_int' keys. |
---|
| 909 | * $pId is the processI. If $pId is 0 then we create a new process, else we are in edit mode. |
---|
| 910 | * if $create is true start and end activities will be created (when importing use $create=false) |
---|
| 911 | * |
---|
| 912 | * @param int $pId Process id, if 0 then we create a new process, else we are in edit mode |
---|
| 913 | * @param array &$vars Associative containing the fields to update or to insert as needed |
---|
| 914 | * @param bool $create If true, start and end activities will be created (when importing use $create=false). |
---|
| 915 | * @return int Process id |
---|
| 916 | * @access public |
---|
| 917 | */ |
---|
| 918 | function replace_process($pId, &$vars, $create = true) |
---|
[795] | 919 | { |
---|
[3167] | 920 | if (!(isset($this->activity_manager))) $this->activity_manager = &Factory::newInstance('ActivityManager'); |
---|
| 921 | $TABLE_NAME = GALAXIA_TABLE_PREFIX.'processes'; |
---|
| 922 | $now = date("U"); |
---|
| 923 | $vars['wf_last_modif']=$now; |
---|
| 924 | $vars['wf_normalized_name'] = $this->_normalize_name($vars['wf_name'],$vars['wf_version']); |
---|
| 925 | $config_array = array(); |
---|
[795] | 926 | |
---|
[3167] | 927 | foreach($vars as $key=>$value) |
---|
| 928 | { |
---|
| 929 | if ($key=='config') |
---|
| 930 | { |
---|
| 931 | $config_array_init =& $value; |
---|
| 932 | // rebuild a nice config_array with type of config and value |
---|
| 933 | if( is_array($config_array_init) && count($config_array_init) > 0 ) |
---|
| 934 | { |
---|
| 935 | foreach($config_array_init as $config) |
---|
| 936 | { |
---|
| 937 | if (isset($config['wf_config_value_int']) && (!($config['wf_config_value_int']==''))) |
---|
| 938 | { |
---|
| 939 | $config_array[$config['wf_config_name']] = array('int' => $config['wf_config_value_int']); |
---|
| 940 | } |
---|
| 941 | else |
---|
| 942 | { |
---|
| 943 | if (isset($config['wf_config_value'])) |
---|
| 944 | { |
---|
| 945 | $config_array[$config['wf_config_name']] = array('text' => $config['wf_config_value']); |
---|
| 946 | } |
---|
| 947 | } |
---|
| 948 | } |
---|
| 949 | } |
---|
| 950 | //no need to keep it in the vars array, this array is used in queries |
---|
| 951 | unset($vars['config']); |
---|
| 952 | } |
---|
| 953 | else // not config, it's just process's fields values |
---|
| 954 | { |
---|
| 955 | $vars[$key]=addslashes($value); |
---|
| 956 | } |
---|
| 957 | } |
---|
[795] | 958 | |
---|
[3167] | 959 | if($pId) { |
---|
| 960 | // update mode |
---|
| 961 | $old_proc = $this->get_process($pId); |
---|
| 962 | $first = true; |
---|
| 963 | $query ="update $TABLE_NAME set"; |
---|
| 964 | foreach($vars as $key=>$value) { |
---|
| 965 | if(!$first) $query.= ','; |
---|
| 966 | if(!is_numeric($value)||strstr($value,'.')) $value="'".$value."'"; |
---|
| 967 | $query.= " $key=$value "; |
---|
| 968 | $first = false; |
---|
| 969 | } |
---|
| 970 | $query .= " where wf_p_id=$pId "; |
---|
| 971 | $this->query($query); |
---|
[795] | 972 | |
---|
[3167] | 973 | //set config values |
---|
| 974 | $this->setConfigValues($pId,$config_array); |
---|
[795] | 975 | |
---|
[3167] | 976 | // Note that if the name is being changed then |
---|
| 977 | // the directory has to be renamed! |
---|
| 978 | $oldname = $old_proc['wf_normalized_name']; |
---|
| 979 | $newname = $vars['wf_normalized_name']; |
---|
| 980 | if ($newname != $oldname) { |
---|
| 981 | rename(GALAXIA_PROCESSES.SEP."$oldname",GALAXIA_PROCESSES.SEP."$newname"); |
---|
| 982 | } |
---|
| 983 | $msg = sprintf(tra('Process %s has been updated'),$vars['wf_name']); |
---|
| 984 | $this->error[] = $msg; |
---|
| 985 | } else { |
---|
| 986 | unset($vars['wf_p_id']); |
---|
| 987 | // insert mode |
---|
| 988 | $name = $this->_normalize_name($vars['wf_name'],$vars['wf_version']); |
---|
| 989 | $this->_create_directory_structure($name); |
---|
| 990 | $first = true; |
---|
| 991 | $query = "insert into $TABLE_NAME("; |
---|
| 992 | foreach(array_keys($vars) as $key) { |
---|
| 993 | if(!$first) $query.= ','; |
---|
| 994 | $query.= "$key"; |
---|
| 995 | $first = false; |
---|
| 996 | } |
---|
| 997 | $query .=") values("; |
---|
| 998 | $first = true; |
---|
| 999 | foreach(array_values($vars) as $value) { |
---|
| 1000 | if(!$first) $query.= ','; |
---|
| 1001 | if(!is_numeric($value)||strstr($value,'.')) $value="'".$value."'"; |
---|
| 1002 | $query.= "$value"; |
---|
| 1003 | $first = false; |
---|
| 1004 | } |
---|
| 1005 | $query .=")"; |
---|
| 1006 | $this->query($query); |
---|
| 1007 | //FIXME: this query seems to be quite sure to get a result, I would prefer something |
---|
| 1008 | // more sure to get the right result everytime |
---|
| 1009 | $pId = $this->getOne("select max(wf_p_id) from $TABLE_NAME where wf_last_modif=$now"); |
---|
[795] | 1010 | |
---|
[3167] | 1011 | //set config values |
---|
| 1012 | $this->setConfigValues($pId,$config_array); |
---|
[795] | 1013 | |
---|
[3167] | 1014 | // Now automatically add a start and end activity |
---|
| 1015 | // unless importing ($create = false) |
---|
| 1016 | if($create) { |
---|
| 1017 | $vars1 = Array( |
---|
| 1018 | 'wf_name' => 'start', |
---|
| 1019 | 'wf_description' => 'default start activity', |
---|
| 1020 | 'wf_type' => 'start', |
---|
| 1021 | 'wf_is_interactive' => 'y', |
---|
| 1022 | 'wf_is_autorouted' => 'y' |
---|
| 1023 | ); |
---|
| 1024 | $vars2 = Array( |
---|
| 1025 | 'wf_name' => 'end', |
---|
| 1026 | 'wf_description' => 'default end activity', |
---|
| 1027 | 'wf_type' => 'end', |
---|
| 1028 | 'wf_is_interactive' => 'n', |
---|
| 1029 | 'wf_is_autorouted' => 'y' |
---|
| 1030 | ); |
---|
[795] | 1031 | |
---|
[3167] | 1032 | $this->activity_manager->replace_activity($pId,0,$vars1); |
---|
| 1033 | $this->activity_manager->replace_activity($pId,0,$vars2); |
---|
| 1034 | } |
---|
| 1035 | $msg = sprintf(tra('Process %s has been created'),$vars['wf_name']); |
---|
| 1036 | $this->error[] = $msg; |
---|
| 1037 | } |
---|
| 1038 | // Get the id |
---|
| 1039 | return $pId; |
---|
| 1040 | } |
---|
| 1041 | |
---|
| 1042 | /** |
---|
| 1043 | * Gets the normalized name of a process by pid |
---|
| 1044 | * |
---|
| 1045 | * @param int $pId Process id |
---|
| 1046 | * @access private |
---|
| 1047 | * @return string |
---|
| 1048 | */ |
---|
| 1049 | function _get_normalized_name($pId) |
---|
| 1050 | { |
---|
| 1051 | $info = $this->get_process($pId); |
---|
| 1052 | return $info['wf_normalized_name']; |
---|
| 1053 | } |
---|
| 1054 | |
---|
| 1055 | /** |
---|
| 1056 | * Normalizes a process name |
---|
| 1057 | * |
---|
| 1058 | * @param string $name Process name to be normalized |
---|
| 1059 | * @param string $version Process version |
---|
| 1060 | * @access private |
---|
| 1061 | * @return string Process normalized name |
---|
| 1062 | */ |
---|
| 1063 | function _normalize_name($name, $version) |
---|
| 1064 | { |
---|
| 1065 | $name = $name.'_'.$version; |
---|
| 1066 | $name = str_replace(" ","_",$name); |
---|
| 1067 | $name = preg_replace("/[^0-9A-Za-z\_]/",'',$name); |
---|
| 1068 | return $name; |
---|
| 1069 | } |
---|
| 1070 | |
---|
| 1071 | /** |
---|
| 1072 | * Generates a new minor version number |
---|
| 1073 | * |
---|
| 1074 | * @param string $version Current process version |
---|
| 1075 | * @param bool $minor Generate minor version |
---|
| 1076 | * @access private |
---|
| 1077 | * @return string |
---|
| 1078 | */ |
---|
| 1079 | function _new_version($version,$minor=true) |
---|
| 1080 | { |
---|
| 1081 | $parts = explode('.',$version); |
---|
| 1082 | if($minor) { |
---|
| 1083 | $parts[count($parts)-1]++; |
---|
| 1084 | } else { |
---|
| 1085 | $parts[0]++; |
---|
| 1086 | for ($i = 1; $i < count($parts); $i++) { |
---|
| 1087 | $parts[$i] = 0; |
---|
| 1088 | } |
---|
| 1089 | } |
---|
| 1090 | return implode('.',$parts); |
---|
| 1091 | } |
---|
| 1092 | |
---|
| 1093 | /** |
---|
| 1094 | * Creates directory structure for process |
---|
| 1095 | * |
---|
| 1096 | * @param string $name Dir name in process repository |
---|
| 1097 | * @access private |
---|
| 1098 | * @return bool |
---|
| 1099 | */ |
---|
| 1100 | function _create_directory_structure($name) |
---|
| 1101 | { |
---|
| 1102 | $path = GALAXIA_PROCESSES.SEP.$name; |
---|
| 1103 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1104 | $path = GALAXIA_PROCESSES.SEP.$name.SEP."resources"; |
---|
| 1105 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1106 | $path = GALAXIA_PROCESSES.SEP.$name.SEP."graph"; |
---|
| 1107 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1108 | $path = GALAXIA_PROCESSES.SEP.$name.SEP."code"; |
---|
| 1109 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1110 | $path = GALAXIA_PROCESSES.SEP.$name.SEP."code".SEP."activities"; |
---|
| 1111 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1112 | $path = GALAXIA_PROCESSES.SEP.$name.SEP."code".SEP."templates"; |
---|
| 1113 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1114 | $path = GALAXIA_PROCESSES.SEP.$name.SEP."code".SEP."jobs"; |
---|
| 1115 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1116 | $path = GALAXIA_PROCESSES.SEP.$name.SEP."smarty"; |
---|
| 1117 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1118 | $path = GALAXIA_PROCESSES.SEP.$name.SEP."smarty".SEP."cache"; |
---|
| 1119 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1120 | $path = GALAXIA_PROCESSES.SEP.$name.SEP."smarty".SEP."compiled"; |
---|
| 1121 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1122 | if (GALAXIA_TEMPLATES) { |
---|
| 1123 | $path = GALAXIA_TEMPLATES.SEP.$name; |
---|
| 1124 | if (!file_exists($path)) mkdir($path,0770); |
---|
| 1125 | } |
---|
| 1126 | // Create shared file |
---|
| 1127 | $file = GALAXIA_PROCESSES.SEP.$name.SEP."code".SEP."shared.php"; |
---|
| 1128 | if (!file_exists($file)) |
---|
| 1129 | { |
---|
| 1130 | $fp = fopen(GALAXIA_PROCESSES.SEP.$name.SEP."code".SEP."shared.php","w"); |
---|
| 1131 | if (!fp) return false; |
---|
| 1132 | fwrite($fp,'<'.'?'.'php'."\n".'?'.'>'); |
---|
| 1133 | fclose($fp); |
---|
| 1134 | } |
---|
| 1135 | } |
---|
| 1136 | |
---|
| 1137 | /** |
---|
| 1138 | * Removes a directory recursively |
---|
| 1139 | * |
---|
| 1140 | * @param string $dir Dir name to be erased |
---|
| 1141 | * @param bool $rec Recursive mode |
---|
| 1142 | * @access private |
---|
| 1143 | * @return void |
---|
| 1144 | */ |
---|
| 1145 | function _remove_directory($dir,$rec=false) |
---|
| 1146 | { |
---|
| 1147 | // Prevent a disaster |
---|
| 1148 | if(trim($dir) == SEP || trim($dir)=='.' || trim($dir)=='templates' || trim($dir)=='templates'.SEP) return false; |
---|
| 1149 | $h = opendir($dir); |
---|
| 1150 | while(($file = readdir($h)) != false) { |
---|
| 1151 | if(is_file($dir.SEP.$file)) { |
---|
| 1152 | @unlink($dir.SEP.$file); |
---|
| 1153 | } else { |
---|
| 1154 | if($rec && $file != '.' && $file != '..') { |
---|
| 1155 | $this->_remove_directory($dir.SEP.$file, true); |
---|
| 1156 | } |
---|
| 1157 | } |
---|
| 1158 | } |
---|
| 1159 | closedir($h); |
---|
| 1160 | @rmdir($dir); |
---|
| 1161 | @unlink($dir); |
---|
| 1162 | } |
---|
| 1163 | |
---|
| 1164 | /** |
---|
| 1165 | * Copies a directory recursively |
---|
| 1166 | * |
---|
| 1167 | * @param string $dir1 Dir name to be copied |
---|
| 1168 | * @param string $dir2 Generated destination dir |
---|
| 1169 | * @access private |
---|
| 1170 | * @return void |
---|
| 1171 | */ |
---|
| 1172 | function _rec_copy($dir1,$dir2) |
---|
| 1173 | { |
---|
| 1174 | @mkdir($dir2,0777); |
---|
| 1175 | $h = opendir($dir1); |
---|
| 1176 | while(($file = readdir($h)) !== false) { |
---|
| 1177 | if(is_file($dir1.SEP.$file)) { |
---|
| 1178 | copy($dir1.SEP.$file,$dir2.SEP.$file); |
---|
| 1179 | } else { |
---|
| 1180 | if($file != '.' && $file != '..') { |
---|
| 1181 | $this->_rec_copy($dir1.SEP.$file, $dir2.SEP.$file); |
---|
| 1182 | } |
---|
| 1183 | } |
---|
| 1184 | } |
---|
| 1185 | closedir($h); |
---|
| 1186 | } |
---|
| 1187 | |
---|
| 1188 | /** |
---|
| 1189 | * XML parser start element handler |
---|
| 1190 | * |
---|
| 1191 | * @param resource $parser Parser handle |
---|
| 1192 | * @param string $element XML tag |
---|
| 1193 | * @param array $attribs XML tag attributes |
---|
| 1194 | * @access private |
---|
| 1195 | * @return void |
---|
| 1196 | */ |
---|
| 1197 | function _start_element_handler($parser, $element, $attribs) |
---|
| 1198 | { |
---|
| 1199 | $aux=Array('name'=>$element, |
---|
| 1200 | 'data'=>'', |
---|
| 1201 | 'parent' => $this->current, |
---|
| 1202 | 'children'=>Array(), |
---|
| 1203 | 'attribs' => $attribs); |
---|
| 1204 | |
---|
| 1205 | $i = count($this->tree); |
---|
| 1206 | $this->tree[$i] = $aux; |
---|
| 1207 | |
---|
| 1208 | $this->tree[$this->current]['children'][]=$i; |
---|
| 1209 | $this->current=$i; |
---|
| 1210 | } |
---|
| 1211 | |
---|
| 1212 | /** |
---|
| 1213 | * XML parser end element handler |
---|
| 1214 | * |
---|
| 1215 | * @param resource $parser Parser handle |
---|
| 1216 | * @param string $element XML tag |
---|
| 1217 | * @param array $attribs XML tag attributes |
---|
| 1218 | * @access private |
---|
| 1219 | * @return void |
---|
| 1220 | */ |
---|
| 1221 | function _end_element_handler($parser, $element) |
---|
| 1222 | { |
---|
| 1223 | //when a tag ends put text |
---|
| 1224 | $this->tree[$this->current]['data']=$this->buffer; |
---|
| 1225 | $this->buffer=''; |
---|
| 1226 | $this->current=$this->tree[$this->current]['parent']; |
---|
| 1227 | } |
---|
| 1228 | |
---|
| 1229 | /** |
---|
| 1230 | * XML parser element data handler |
---|
| 1231 | * |
---|
| 1232 | * @param resource $parser Parser handle |
---|
| 1233 | * @param string $element XML tag |
---|
| 1234 | * @param string $data XML tag content |
---|
| 1235 | * @access private |
---|
| 1236 | * @return void |
---|
| 1237 | */ |
---|
| 1238 | function _data_handler($parser, $data) |
---|
| 1239 | { |
---|
| 1240 | $this->buffer .= $data; |
---|
| 1241 | } |
---|
| 1242 | |
---|
| 1243 | /** |
---|
| 1244 | * This getConfigValues differs from the Process::getConfigValues because requires only process id. |
---|
| 1245 | * This method gets the items defined in process_config table for this process, in fact this admin function bypass |
---|
| 1246 | * the process behaviour and is just showing you the basic content of the table. |
---|
| 1247 | * All config items are returned as a function result. |
---|
| 1248 | * |
---|
| 1249 | * @param int $pId Process id |
---|
| 1250 | * @param bool $distinct_types If the distinct_type is set the returned array will follow the format: |
---|
| 1251 | * * 0 =>('wf_config_name'=> 'foo') |
---|
| 1252 | * =>('wf_config_value'=>'bar') |
---|
| 1253 | * =>('wf_config_vale_int'=>null) |
---|
| 1254 | * * 1 =>('wf_config_name' => 'toto') |
---|
| 1255 | * =>('wf_config_value'=>'') |
---|
| 1256 | * =>('wf_config_vale_int'=>15) |
---|
| 1257 | * if set to false (default) the result array will be (note that this is the default result if having just the $pId): |
---|
| 1258 | * * 'foo'=>'bar' |
---|
| 1259 | * * 'toto'=>15 |
---|
| 1260 | * @param bool $askProcessObject If the askProcessObject is set to true (false by default) then the ProcessManager will load a process |
---|
| 1261 | * object to run directly Process->getConfigValues($config_ask_array) this let you use this ProcessManager |
---|
| 1262 | * getConfigValues the same way you would use $process->getConfigValues, with initialisation of default values. |
---|
| 1263 | * you should then call this function this way: $conf_result=$pm->getConfigValues($pId,true,true,$my_conf_array) |
---|
| 1264 | * @param array $config_array |
---|
| 1265 | * @access public |
---|
| 1266 | * @return array |
---|
| 1267 | */ |
---|
| 1268 | function getConfigValues($pId, $distinct_types=false, $askProcessObject=false, $config_array=array()) |
---|
| 1269 | { |
---|
| 1270 | if (!$askProcessObject) |
---|
| 1271 | { |
---|
| 1272 | $query = 'select * from '.GALAXIA_TABLE_PREFIX.'process_config where wf_p_id=?'; |
---|
| 1273 | $result = $this->query($query, array($pId)); |
---|
| 1274 | $result_array=array(); |
---|
| 1275 | while($res = $result->fetchRow()) |
---|
| 1276 | { |
---|
| 1277 | if ( (!$distinct_types) ) |
---|
| 1278 | {// we want a simple array |
---|
| 1279 | if ($res['wf_config_value_int']==null) |
---|
| 1280 | { |
---|
| 1281 | $result_array[$res['wf_config_name']] = $res['wf_config_value']; |
---|
| 1282 | } |
---|
| 1283 | else |
---|
| 1284 | { |
---|
| 1285 | $result_array[$res['wf_config_name']] = $res['wf_config_value_int']; |
---|
| 1286 | } |
---|
| 1287 | } |
---|
| 1288 | else |
---|
| 1289 | {// build a more complex result array, which is just the table rows |
---|
| 1290 | $result_array[] = $res; |
---|
| 1291 | } |
---|
| 1292 | } |
---|
| 1293 | } |
---|
| 1294 | else //we'll load a Process object and let him work for us |
---|
| 1295 | { |
---|
| 1296 | //Warning: this means you have to include the Process.php from the API |
---|
| 1297 | $this->Process = &Factory::newInstance('Process'); |
---|
| 1298 | $this->Process->getProcess($pId); |
---|
| 1299 | $result_array = $this->Process->getConfigValues($config_array); |
---|
| 1300 | unset ($this->Process); |
---|
| 1301 | } |
---|
| 1302 | return $result_array; |
---|
| 1303 | } |
---|
| 1304 | |
---|
| 1305 | /** |
---|
| 1306 | * Calls a process object to save his new config values by taking a process Id as first argument and simply call |
---|
| 1307 | * this process's setConfigValues method. We let the process define the better way to store the data given as second arg. |
---|
| 1308 | * |
---|
| 1309 | * @param int $pId Process id |
---|
| 1310 | * @param array &$config_array |
---|
| 1311 | * @return void |
---|
| 1312 | * @access public |
---|
| 1313 | */ |
---|
| 1314 | function setConfigValues($pId, &$config_array) |
---|
| 1315 | { |
---|
| 1316 | //Warning: this means you have to include the Process.php from the API |
---|
| 1317 | $this->Process = &Factory::newInstance('Process'); |
---|
| 1318 | $this->Process->getProcess($pId); |
---|
| 1319 | $this->Process->setConfigValues($config_array); |
---|
| 1320 | unset ($this->Process); |
---|
| 1321 | } |
---|
| 1322 | |
---|
| 1323 | /** |
---|
| 1324 | * Gets available agents list |
---|
| 1325 | * |
---|
| 1326 | * @return array |
---|
| 1327 | * @access public |
---|
| 1328 | */ |
---|
| 1329 | function get_agents() |
---|
| 1330 | { |
---|
| 1331 | return galaxia_get_agents_list(); |
---|
| 1332 | } |
---|
| 1333 | |
---|
| 1334 | /** |
---|
| 1335 | * Gets the view activity id avaible for a given process |
---|
| 1336 | * |
---|
| 1337 | * @param int $pId Process Id |
---|
| 1338 | * @return bool False if no view activity is avaible for the process, return the activity id if there is one |
---|
| 1339 | * @access public |
---|
| 1340 | */ |
---|
| 1341 | function get_process_view_activity($pId) |
---|
| 1342 | { |
---|
| 1343 | $mid = 'where gp.wf_p_id=? and ga.wf_type=?'; |
---|
| 1344 | $bindvars = array($pId,'view'); |
---|
| 1345 | $query = 'select ga.wf_activity_id |
---|
| 1346 | from '.GALAXIA_TABLE_PREFIX.'processes gp |
---|
| 1347 | INNER JOIN '.GALAXIA_TABLE_PREFIX."activities ga ON gp.wf_p_id=ga.wf_p_id |
---|
| 1348 | $mid"; |
---|
| 1349 | $result = $this->query($query,$bindvars); |
---|
| 1350 | $ret = Array(); |
---|
| 1351 | $retval = false; |
---|
| 1352 | if (!(empty($result))) |
---|
| 1353 | { |
---|
| 1354 | while($res = $result->fetchRow()) |
---|
| 1355 | { |
---|
| 1356 | $retval = $res['wf_activity_id']; |
---|
| 1357 | } |
---|
| 1358 | } |
---|
| 1359 | return $retval; |
---|
| 1360 | } |
---|
| 1361 | |
---|
[795] | 1362 | } |
---|
| 1363 | |
---|
| 1364 | |
---|
| 1365 | ?> |
---|