source: trunk/workflow/inc/engine/src/ProcessManager/ProcessManager.php @ 4740

Revision 4740, 43.6 KB checked in by viani, 13 years ago (diff)

Ticket #2119 - Inclusão de parâmetro size no plugin wf_select_user
  • Property svn:executable set to *
Line 
1<?php
2require_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
6 *
7 * @todo Fix multiple non checked fopen ==> infinite loops in case of problems with filesystem
8 * @package Galaxia
9 * @license http://www.gnu.org/copyleft/gpl.html GPL
10 */
11class ProcessManager extends BaseManager {
12
13        /**
14         * @var resource $parser xml parser
15         * @access public
16         */
17        var $parser;
18
19        /**
20         * @var array $tree data struture
21         * @access public
22         */
23        var $tree;
24
25        /**
26         * @var $current current element
27         * @access public
28         */
29        var $current;
30
31        /**
32         * @var $buffer buffer for data
33         * @access public
34         */
35        var $buffer;
36
37        /**
38         * @var object $Process Process
39         * @access public
40         */
41        var $Process;
42
43        /**
44         * @var object $activity_manager Activity Manager
45         * @access public
46         */
47        var $activity_manager;
48
49        /**
50         * @var object $jobManager Job Manager object
51         * @access public
52         */
53        var $jobManager;
54
55        /**
56         * @var object $role_manager Role Manager
57         * @access public
58         */
59        var $role_manager;
60
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        }
75
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        }
91
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        }
106
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        }
121
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";
143
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";
153
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";
167
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";
219
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        }
258
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;
286
287
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
297
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']);
305
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        }
448
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
482                if (ereg('^[0-9]{1,2}\.[0-9]{1,2}$', $vars['wf_version']) === false)
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        {
801                if(!empty($sort_mode))
802                        $sort_mode = $this->convert_sortmode($sort_mode);
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
836  /*!
837   Marks a process as an invalid process
838   */
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        }
844
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);
859
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)
919        {
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();
926
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                }
958
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);
972
973                        //set config values
974                        $this->setConfigValues($pId,$config_array);
975
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");
1010
1011                        //set config values
1012                        $this->setConfigValues($pId,$config_array);
1013
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                                );
1031
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
1362}
1363
1364
1365?>
Note: See TracBrowser for help on using the repository browser.