source: trunk/contactcenter/inc/class.bo_global_ldap_catalog.inc.php @ 1598

Revision 1598, 39.2 KB checked in by rafaelraymundo, 14 years ago (diff)

Ticket #704 - Incluido outro campo para busca utilizando atributo do LDAP

  • Property svn:eol-style set to native
  • Property svn:executable set to *
Line 
1<?php
2  /***************************************************************************\
3  * eGroupWare - Contacts Center                                              *
4  * http://www.egroupware.org                                                 *
5  * Written by:                                                               *
6  *  - Raphael Derosso Pereira <raphaelpereira@users.sourceforge.net>         *
7  * ------------------------------------------------------------------------- *
8  *  This program is free software; you can redistribute it and/or modify it  *
9  *  under the terms of the GNU General Public License as published by the    *
10  *  Free Software Foundation; either version 2 of the License, or (at your   *
11  *  option) any later version.                                               *
12  \***************************************************************************/
13
14        /*
15                This class is responsible for manipulating the Global LDAP Contact Manager
16        */
17        include_once('class.abo_catalog.inc.php');
18       
19        class bo_global_ldap_catalog extends abo_catalog
20        {
21                var $ldap;
22       
23                var $src_info;
24               
25                var $trans_table;
26                // used to determine if a catalog is external
27                var $external;
28                var $fields = array(
29                        'id_contact'    => true,
30                        'status'        => true,
31                        'photo'         => true,
32                        'alias'         => true,
33                        'prefix'        => true,
34                        'given_names'   => true,
35                        'family_names'  => true,
36                        'account_type'  => true,
37                        'names_ordered' => true,
38                        'suffix'        => true,
39                        'birthdate'     => true,
40                        'sex'           => true,
41                        'pgp_key'       => true,
42                        'notes'         => true,
43                        'companies'     => true,
44                        'relations'     => true,
45                        'addresses'     => true,
46                        'connections'   => true
47                );
48               
49                /*
50               
51                        @function global_ldap_catalog
52                        @abstract Constructor
53                        @author Raphael Derosso Pereira
54                        @author Mário César Kolling (external catalogs)
55
56                        @param integer $id_source The ID of the LDAP source
57                        @param string $context Ldap bind DN
58                        @param integer $external 0 = internal catalog, 1 = external catalog
59                */
60                function bo_global_ldap_catalog ( $id_source, $context, $external = 0 )
61                {
62                        $this->external = $external;
63                        if (!function_exists('ldap_search'))
64                        {
65                                exit('PHP LDAP support Unavailable!');
66                        }
67                       
68                        $this->ldap = CreateObject('contactcenter.bo_ldap_manager');
69                       
70                        if ($this->external)
71                        {
72                                $all_src = $this->ldap->get_external_ldap_sources();
73                        }
74                        else
75                        {
76                                $all_src = $this->ldap->get_all_ldap_sources();
77                        }
78
79                        if (!$all_src[$id_source] or !$context)
80                        {
81                                exit('Unavailable LDAP source.');
82                        }
83
84                        $this->src_info = $all_src[$id_source];
85                        $this->src_info['context'] = $context;
86
87                        if ($this->external)
88                        {
89                                $this->trans_table = $this->ldap->get_external_ldap_fields_association($id_source);
90                        }
91                        else
92                        {       
93                                $this->trans_table = $this->ldap->get_ldap_fields_association($id_source);
94                        }
95                }
96               
97                /*
98               
99                        @function find
100                        @abstract Searches the LDAP directory for the specified fields with
101                                the specified rules and retuns an array containing all the DNs
102                                that matches the rules.
103                        @author Raphael Derosso Pereira
104                       
105                        @param array $what The fields to be taken
106                        @param array $rules The rules to be match. See class.abo_catalog.inc.php
107                                for reference
108                        @param array $other Other parameters:
109                                $return = array(
110                                        'limit'  => (integer),
111                                        'offset' => (integer) [NOT IMPLEMENTED]
112                                )
113               
114                */
115                function find($what, $rules=false, $other=false, $area=false)
116                {
117                        $restric_fields = $this->get_restrictions_without_branch($rules);
118                       
119                        $trans_f = $this->translate_fields($what, $restric_fields);
120                       
121                        foreach($trans_f as $orig => $field_a)
122                        {
123                                foreach($field_a as $field)
124                                {
125                                        $fields[] = $field;
126                                }
127                        }
128
129                        $fields = array_unique($fields);
130                       
131            //Testa se a busca foi realizada com aspas
132            $rules_search = $rules[3]['value'];
133            $rules_len = (strlen($rules_search)) -1;
134
135            if((($rules_search{1}) == "\"") && (($rules_search{$rules_len -1}) == "\"")){
136                                $rules_search = substr($rules_search,2,$rules_len-3);
137                                $filter = "(&(|(objectClass=phpgwAccount))(&(!(phpgwAccountVisible=-1)))(|(cn=* $rules_search *)(cn=$rules_search *)(cn=* $rules_search)))";
138            }
139            else{
140                                $filter = $this->process_restrictions($rules, $trans_f);
141            }
142                       
143            if ($area)
144            {
145                 $obj = CreateObject('phpgwapi.config','contactcenter');
146                 $opts = $obj->read_repository();
147                 $filter = substr($filter,0,-1) .'(' . $opts['cc_ldap_atrib'] . '=*' . $area . '*))';
148                 $opts = null;
149                 $obj = null;
150            }
151            // Find objects where 'mail' attribute is not null.
152                        $filter = "(&".$filter."(mail=*))";
153
154                        if(strstr($this->src_info['context'], "ldap://")) {
155                                $refer_context  = str_replace("??base","",preg_replace('!^(ldap://[^/]+)/(.*$)!', '\\2', $this->src_info['context']));
156                                $host   = preg_replace('!^(ldap://[^/]+)/.*$!', '\\1', $this->src_info['context']);
157                                $this->src_info['host'] = $host;
158                        }
159                        if($refer_context || "ou" === strtolower(substr($this->src_info['context'], 0, 2)))
160                        {
161                                $followReferral = false;
162                        }
163                        elseif(trim($rules[4]['value']) != "inetOrgPerson")
164                        {
165                                $followReferral = true;
166                        }
167                        else
168                        {                               
169                                return false;
170                        }
171                       
172                        $ldap = $GLOBALS['phpgw']->common->ldapConnect($this->src_info['host'], $this->src_info['acc'], $this->src_info['pw'], $followReferral);
173                        $result_r = ldap_search($ldap ,($refer_context  ? $refer_context  : $this->src_info['context']), $filter, $fields, 0, $this->src_info['max_results']);
174
175                        if (!$result_r)
176                        {
177                                return false;
178                        }
179                       
180                        if ($other['order'])
181                        {
182                                $sort_f = array($other['order']);
183                                $ldap_sort_by = $this->translate_fields($sort_f, $restric_fields);
184                        }
185
186                        if ($ldap_sort_by)
187                        {
188                                if (!ldap_sort($ldap, $result_r, $ldap_sort_by[$other['order']][0]))
189                                {
190                                        return false;
191                                }
192                        }
193                       
194                        $result_u = ldap_get_entries($ldap, $result_r);
195                       
196                        $i = 0;
197                        foreach ($result_u as $index => $result_p)
198                        {
199                                if ($index === 'count' or $index === 'dn' or (!$this->external and $result_p['phpgwaccountvisible'][0] == '-1'))
200                                {
201                                        continue;
202                                }
203                               
204                                foreach ($trans_f as $orig => $trans)
205                                {
206                                        $orig = substr($orig, strrpos($orig, '.')+1, strlen($orig));
207                                        foreach ($trans as $f)
208                                        {
209                                                if ($f === 'dn')
210                                                {
211                                                        $return[$i][$orig] = $result_p['dn'];
212                                                }
213                                                else if ($result_p[$f][0])
214                                                {
215                                                        $return[$i][$orig] = $result_p[$f][0];
216                                                }
217                                        }
218                                }
219                                $i++;
220                        }
221                        usort($return, array($this, "compareObjects"));
222                        return $return;
223                }
224                // Compare function for usort.
225                function compareObjects($a, $b) {
226                        return strnatcasecmp($a['names_ordered'], $b['names_ordered']);
227                }
228               
229                /*
230               
231                        @function translate_fields
232                        @abstract Return the LDAP objectClass fields that corresponds to the
233                                specified parameter fields
234                        @author Raphael Derosso Pereira
235                       
236                        @param array $fields The fields in the standard ContactCenter format
237                        @param array $rules The rules
238               
239                */
240                function translate_fields ( $fields, &$restric_fields )
241                {
242                        $return = array();
243                       
244                        $i = 0;
245                        foreach ($fields as $field)
246                        {
247                                if (!array_key_exists($field,$this->trans_table) or !$this->trans_table[$field])
248                                {
249                                        continue;
250                                }
251                               
252                                if (!is_array($this->trans_table[$field]))
253                                {
254                                        $reference = $this->trans_table[$field];
255                                       
256                                        reset($restric_fields);
257                                        while(list(,$field_r) = each($restric_fields))
258                                        {
259                                                if ($field_r['field'] === $reference and array_key_exists($field_r['value'], $this->trans_table[$reference]))
260                                                {
261                                                        array_push($return[$field], $this->trans_table[$reference][$field_r['value']]);
262                                                }
263                                        }
264                                }
265                                else
266                                {
267                                        if (!is_array($return[$field]))
268                                        {
269                                                $return[$field] = $this->trans_table[$field];
270                                        }
271                                        else
272                                        {
273                                                array_push($return[$field], $this->trans_table[$field]);
274                                        }
275                                }
276                        }
277                       
278                        if (count($return))
279                        {
280                                return $return;
281                        }
282                       
283                        return false;
284                }
285               
286                /*
287               
288                        @function process_restrictions
289                        @abstract Returns a LDAP filter string that corresponds to the
290                                specified restriction rules
291                        @author Raphael Derosso Pereira
292                       
293                        @param string $rules The restriction rules
294               
295                */
296                function process_restrictions( $rules, &$trans_table, $join_type='&' )
297                {
298                        if (!is_array($rules) or !count($rules))
299                        {
300                                return null;
301                        }
302                       
303                        foreach($rules as $rule_i => $rule)
304                        {
305                                $t = array();
306                                switch($rule['type'])
307                                {
308                                        case 'branch':
309                                                switch(strtoupper($rule['value']))
310                                                {
311                                                        case 'OR':
312                                                                $join = '|';
313                                                                break;
314                                                               
315                                                        case 'AND':
316                                                                $join = '&';
317                                                                break;
318                                                               
319                                                        case 'NOT':
320                                                                $join = '!';
321                                                                break;
322                                                               
323                                                        default:
324                                                                $join = $join_type;
325                                                }
326                                                $return_t[] = $this->process_restrictions($rule['sub_branch'], $trans_table, $join);
327                                                break;
328                                               
329                                        case '=':
330                                                if (array_key_exists($rule['field'], $trans_table))
331                                                {
332                                                        foreach($trans_table[$rule['field']] as $field)
333                                                        {
334                                                                $t[] = '('.$field.'='.$rule['value'].')';
335                                                        }
336                                                        $return_t[] = '(|'.implode(' ',$t).')';
337                                                }
338                                                break;
339                                       
340                                        case '!=':     
341                                                if (array_key_exists($rule['field'], $trans_table))
342                                                {
343                                                        foreach($trans_table[$rule['field']] as $field)
344                                                        {
345                                                                $t[] = '(!('.$field.'='.$rule['value'].'))';
346                                                        }
347                                                        $return_t[] = '(&'.implode(' ',$t).')';
348                                                }
349                                                break;
350                                       
351                                        case '<=':
352                                        case '<':
353                                                if (array_key_exists($rule['field'], $trans_table))
354                                                {
355                                                        foreach($trans_table[$rule['field']] as $field)
356                                                        {
357                                                                $t[] = '('.$field.'<='.$rule['value'].')';
358                                                        }
359                                                        $return_t[] = '(|'.implode(' ',$t).')';
360                                                }
361                                                break;
362                                       
363                                        case '>':
364                                        case '>=':
365                                                if (array_key_exists($rule['field'], $trans_table))
366                                                {
367                                                        foreach($trans_table[$rule['field']] as $field)
368                                                        {
369                                                                $t[] = '('.$field.'>='.$rule['value'].')';
370                                                        }
371                                                        $return_t[] = '(|'.implode(' ',$t).')';
372                                                }
373                                                break;
374                                               
375                                        case 'NULL':
376                                                if (array_key_exists($rule['field'], $trans_table))
377                                                {
378                                                        foreach($trans_table[$rule['field']] as $field)
379                                                        {
380                                                                $t[] = '(!('.$field.'=*'.'))';
381                                                        }
382                                                        $return_t[] = '(&'.implode(' ',$t).')';
383                                                }
384                                                break;
385                                       
386                                        case 'IN':
387                                                if (array_key_exists($rule['field'], $trans_table))
388                                                {
389                                                        foreach($trans_table[$rule['field']] as $field)
390                                                        {
391                                                                foreach($rule['value'] as $value)
392                                                                {
393                                                                        $t[] = '('.$field.'='.$value.')';
394                                                                }
395                                                        }
396                                                        $return_t[] = '(|'.implode(' ',$t).')';
397                                                }
398                                                break;
399
400                                        case 'iLIKE':
401/*                                              if (array_key_exists($rule['field'], $trans_table))
402                                                {
403                                                        $value_1 = strtoupper(str_replace('%', '*', $rule['value']));
404                                                        $value_2 = strtolower($value_1);
405                                                       
406                                                        foreach($trans_table[$rule['field']] as $field)
407                                                        {
408                                                                $t[] = '('.$field.'='.$value_1.')';
409                                                                $t[] = '('.$field.'='.$value_2.')';
410                                                        }
411                                                        $return_t[] = '(|'.implode(' ',$t).')';
412                                                }
413                                                break;
414                                               
415*/                                      case 'LIKE':
416                                                if (array_key_exists($rule['field'], $trans_table))
417                                                {
418                                                        $value = str_replace('%', '*', $rule['value']);
419                                                       
420                                                        foreach($trans_table[$rule['field']] as $field)
421                                                        {
422                                                                $t[] = '('.$field.'='.$value.')';
423                                                        }
424                                                        $return_t[] = '(|'.implode(' ',$t).')';
425                                                }
426                                                break;
427                                               
428                                        case 'NOT NULL':
429                                                if (array_key_exists($rule['field'], $trans_table))
430                                                {
431                                                        foreach($trans_table[$rule['field']] as $field)
432                                                        {
433                                                                $t[] = '('.$field.'=*'.')';
434                                                        }
435                                                        $return_t[] = '(|'.implode(' ',$t).')';
436                                                }
437                                                break;
438                                       
439                                        case 'NOT IN':
440                                                if (array_key_exists($rule['field'], $trans_table))
441                                                {
442                                                        foreach($trans_table[$rule['field']] as $field)
443                                                        {
444                                                                foreach($rule['value'] as $value)
445                                                                {
446                                                                        $t[] = '('.$field.'='.$value.')';
447                                                                }
448                                                        }
449                                                        $return_t[] = '(!(|'.implode('',$t).'))';
450                                                }
451                                                break;
452
453                                        case 'NOT iLIKE':
454                                                if (array_key_exists($rule['field'], $trans_table))
455                                                {
456                                                        $value_1 = strtoupper(str_replace('%', '*', $rule['value']));
457                                                        $value_2 = strtolower($value_1);
458                                                       
459                                                        foreach($trans_table[$rule['field']] as $field)
460                                                        {
461                                                                $t[] = '('.$field.'='.$value_1.')';
462                                                                $t[] = '('.$field.'='.$value_2.')';
463                                                        }
464                                                        $return_t[] = '(!(|'.implode(' ',$t).'))';
465                                                }
466                                                break;
467
468                                        case 'NOT LIKE':
469                                                if (array_key_exists($rule['field'], $trans_table))
470                                                {
471                                                        $value = str_replace('%', '*', $rule['value']);
472                                                       
473                                                        foreach($trans_table[$rule['field']] as $field)
474                                                        {
475                                                                $t[] = '('.$field.'='.$value.')';
476                                                        }
477                                                        $return_t[] = '(!(|'.implode(' ',$t).'))';
478                                                }
479                                                break;
480                                }
481                        }
482                       
483                        if (count($return_t))
484                        {
485                                $return = '('.$join_type;
486                                foreach ($return_t as $return_p)
487                                {
488                                        $return .= $return_p;
489                                }
490                                $return .= ')';
491                        }
492                        else
493                        {
494                                $return = null;
495                        }
496                        return $return;
497                }
498
499                /*!
500               
501                        @function get_restrictions_without_branch
502                        @abstract Returns an array containing the restrictions ignoring the
503                                branches
504                        @author Raphael Derosso Pereira
505                       
506                        @param array $restrictions The restrictions
507               
508                */
509                function get_restrictions_without_branch(&$restrictions)
510                {
511                        if (!is_array($restrictions))
512                        {
513                                return null;
514                        }
515                       
516                        $fields = array();
517                       
518                        foreach ($restrictions as $restrict_data)
519                        {
520                                switch($restrict_data['type'])
521                                {
522                                        case 'branch':
523                                                $fields = array_merge($fields, $this->get_restrictions_without_branch($restrict_data['sub_branch']));
524                                                break;
525                                               
526                                        case '=':
527                                        case '!=':     
528                                        case '<=':
529                                        case '<':
530                                        case '>':
531                                        case '>=':
532                                        case 'NULL':
533                                        case 'IN':
534                                        case 'LIKE':
535                                        case 'iLIKE':
536                                        case 'NOT NULL':
537                                        case 'NOT IN':
538                                        case 'NOT LIKE':
539                                        case 'NOT iLIKE':
540                                                array_push($fields, $restrict_data);
541                                                break;
542                                               
543                                        default:
544                                                exit('Error in '.__FILE__.' on '.__LINE__.'<br>The restriction type passed was: '.$restrict_data['type']);                                     
545                                }
546                        }
547                       
548                        return $fields;
549                }
550               
551               
552                /*********************************************************************\
553                 *                        Methods to Get Data                        *
554                \*********************************************************************/
555               
556       
557                /*!
558               
559                 @function get_single_entry
560                 @abstract Returns all information requested about one contact
561                 @author Raphael Derosso Pereira
562                     
563                 @param integer $id_contact The contact ID
564                 @param array $fields The array returned by get_fields with true
565                        on the fields to be taken.
566                       
567                */
568                function get_single_entry ( $id_contact, $fields, $external=false )
569                {
570                        if (!is_array($fields))
571                        {
572                                if (is_object($GLOBALS['phpgw']->log))
573                                {
574                                        $GLOBALS['phpgw']->log->message(array(
575                                                'text' => 'F-BadcontactcenterParam, wrong get_single_entry parameters type.',
576                                                'line' => __LINE__,
577                                                'file' => __FILE__));
578                                       
579                                        $GLOBALS['phpgw']->log->commit();
580                                }
581                                else
582                                {
583                                        exit('Argument Error on: <br>File:'.__FILE__.'<br>Line:'.__LINE__.'<br>');
584                                }
585                        }
586                       
587                        $ldap = $GLOBALS['phpgw']->common->ldapConnect($this->src_info['host'],$this->src_info['acc'],$this->src_info['pw'],true);
588                       
589                        if (!$ldap)
590                        {
591                                return false;
592                        }
593                        if(!$external)
594                                $id_contact = preg_replace("/dc=(.*)/i",$this->src_info['dn'],$id_contact);
595                       
596                        $resource = @ldap_read($ldap, $id_contact, 'objectClass='.$this->src_info['obj']);
597                        $n_entries = @ldap_count_entries($ldap, $resource);
598                        if ( $n_entries > 1 or $n_entries < 1)
599                        {
600                                return false;
601                        }
602                       
603                        $first_entry = ldap_first_entry($ldap, $resource);
604                        $contact = ldap_get_attributes($ldap,$first_entry);
605                        if($contact['jpegPhoto']){     
606                                $contact['jpegPhoto'] = ldap_get_values_len ($ldap, $first_entry, "jpegPhoto");
607                        }
608
609//                      print_r($contact);
610                       
611                //      $contact_data = $this->fields;
612                       
613                        foreach($fields as $field => $trueness)
614                        {
615                                if (!$trueness)
616                                {
617                                        //unset($contact_data[$field]);
618                                        continue;
619                                }
620                               
621                                switch ($field)
622                                {
623                                        case 'companies':
624                                                unset($l_fields);
625                                                $l_fields['company_name']  = $this->trans_table['contact.company.company_name'];
626                                                $l_fields['title']         = $this->trans_table['contact.business_info.title'];
627                                                //$l_fields['department']    = $this->trans_table['contact.business_info.department'];
628                                                $l_fields['company_notes'] = $this->trans_table['contact.company.company_notes'];
629
630                                                //Relaciona o array com o atributo 'ou' do RHDS; tambem verifica se a
631                                                //preferencia esta configurada para exibir o campo
632                                                if(isset($_SESSION['phpgw_info']['user']['preferences']['contactcenter']['departmentShow']) && $_SESSION['phpgw_info']['user']['preferences']['contactcenter']['departmentShow'])
633                                                {
634                                                        $l_fields['department']    = $this->trans_table['contact.business_info.department'];
635                                                }
636                                                //Relaciona o array com o atributo 'employeeNumber' do RHDS; tambem verifica se a
637                                                //preferencia esta configurada para exibir o campo
638                                                if(isset($_SESSION['phpgw_info']['user']['preferences']['contactcenter']['empNumShow']) && $_SESSION['phpgw_info']['user']['preferences']['contactcenter']['empNumShow'])
639                                                {
640                                                        $l_fields['empNumber']     = $this->trans_table['contact.business_info.empNumber'];
641                                                }
642                                                //Relaciona o array com o atributo 'mobile' do RHDS; tambem verifica se a
643                                                //preferencia esta configurada para exibir o campo
644                                                if(isset($_SESSION['phpgw_info']['user']['preferences']['contactcenter']['cellShow']) && $_SESSION['phpgw_info']['user']['preferences']['contactcenter']['cellShow'])
645                                                {
646                                                        $l_fields['celPhone']     = $this->trans_table['contact.business_info.celPhone'];
647                                                }
648
649                                                $contact_data['companies'] = array();
650                                                foreach($l_fields as $l_field => $l_value)
651                                                {
652                                                        if (!( $contact[$l_value[0]][0]))
653                                                        {
654                                                                continue;
655                                                        }
656                                                       
657                                                        $contact_data['companies']['company1'][$l_field] = utf8_decode($contact[$l_value[0]][0]);
658                                                }
659                                               
660                                                if (!(count($contact_data['companies'])))
661                                                {
662                                                        unset($contact_data['companies']);
663                                                }
664                                                break;
665                                       
666                                        case 'relations':
667                                                unset($l_fields);
668                                                if (!$this->trans_table['contact.contact_related.names_ordered'])
669                                                {
670                                                        unset($contact_data['relations']);
671                                                }
672                                               
673                                                $contact_data['relations'] = array();
674                                                if (!is_array($this->trans_table['contact.contact_related.names_ordered']))
675                                                {
676                                                        if (!($trans = $this->trans_table[$this->trans_table['contact.contact_related.names_ordered']]))
677                                                        {
678                                                                continue;
679                                                        }
680                                                       
681                                                        $i = 1;
682                                                        foreach($trans as $l_type => $l_type_fields)
683                                                        {
684                                                                if (!($contact[$l_type_fields[0]][0]))
685                                                                {
686                                                                        continue;
687                                                                }
688                                                               
689                                                                $contact_data['relations']['relation'.$i]['type'] = $l_type;
690                                                                $contact_data['relations']['relation'.$i]['names_ordered'] = utf8_decode($contact[$l_type_fields[0]][0]);
691                                                                $i++;
692                                                        }
693                                                }
694                                               
695                                                if (!(count($contact_data['relations'])))
696                                                {
697                                                        unset($contact_data['relations']);
698                                                }
699                                                break;
700                                       
701                                        case 'addresses':
702                                                unset($l_fields);
703                                                $l_fields['address1'] = $this->trans_table['contact.address.address1'];
704                                                $l_fields['address2'] = $this->trans_table['contact.address.address2'];
705                                                $l_fields['complement'] = $this->trans_table['contact.address.complement'];
706                                                $l_fields['address_other'] = $this->trans_table['contact.address.address_other'];
707                                                $l_fields['postal_code'] = $this->trans_table['contact.address.postal_code'];
708                                                $l_fields['po_box'] = $this->trans_table['contact.address.po_box'];
709                                                $l_fields['id_city'] = $this->trans_table['contact.address.city.id_city'];
710                                                $l_fields['city_name'] = $this->trans_table['contact.address.city.city_name'];
711                                                $l_fields['city_timezone'] = $this->trans_table['contact.address.city.city_timezone'];
712                                                $l_fields['city_geo_location'] = $this->trans_table['contact.address.city.city_geo_location'];
713                                                $l_fields['id_state'] = $this->trans_table['contact.address.city.state.id_state'];
714                                                $l_fields['state_name'] = $this->trans_table['contact.address.city.state.state_name'];
715                                                $l_fields['state_symbol'] = $this->trans_table['contact.address.city.state.state_symbol'];
716                                                $l_fields['id_country'] = $this->trans_table['contact.address.city.country.id_country'];
717                                                $l_fields['country_name'] = $this->trans_table['contact.address.city.country.country_name'];
718                                                $l_fields['address_is_default'] = $this->trans_table['contact.address.address_is_default'];
719
720                                                $contact_data['addresses'] = array();
721                                                foreach($l_fields as $l_field => $l_value)
722                                                {
723                                                        if (!is_array($l_value))
724                                                        {
725                                                                if (!($trans = $this->trans_table[$l_value]))
726                                                                {
727                                                                        continue;
728                                                                }
729                                                               
730                                                                $i = 1;
731                                                                foreach($trans as $l_type => $l_type_fields)
732                                                                {
733                                                                        if (!($contact[$l_type_fields[0]][0]))
734                                                                        {
735                                                                                continue;
736                                                                        }
737                                                                       
738                                                                        $contact_data['addresses']['address'.$i]['type'] = $l_type;
739                                                                        $contact_data['addresses']['address'.$i][$l_field] = utf8_decode($contact[$l_type_fields[0]][0]);
740                                                                        $i++;
741                                                                }
742                                                        }
743                                                        else
744                                                        {
745                                                                $contact_data['addresses']['address1'][$l_field] = utf8_decode($contact[$l_value[0]][0]);
746                                                        }
747                                                }
748                                               
749                                                if (!(count($contact_data['addresses'])))
750                                                {
751                                                        unset($contact_data['addresses']);
752                                                }
753                                                break;
754                                       
755                                        case 'connections':
756                            $preferences = ExecMethod('contactcenter.ui_preferences.get_preferences');
757                            if (!is_array($preferences))
758                            {
759                                                        $preferences['personCardEmail'] = 1;
760                                                        $preferences['personCardPhone'] = 2;
761                                                }
762                                                unset($l_fields);
763                                                $l_fields['connection_name'] = $this->trans_table['contact.connection.connection_name'];
764                                                $l_fields['connection_value'] = $this->trans_table['contact.connection.connection_value'];
765
766                                                $contact_data['connections'] = array();
767                                                foreach($l_fields as $l_field => $l_value)
768                                                {
769                                                        if (!is_array($l_value))
770                                                        {
771                                                                if (!($trans = $this->trans_table[$l_value]))
772                                                                {
773                                                                        continue;
774                                                                }
775                                                               
776                                                                $i = 1;
777                                                                foreach($trans as $l_type => $l_type_fields)
778                                                                {
779                                                                        if (!($contact[$l_type_fields[0]][0]))
780                                                                        {
781                                                                                continue;
782                                                                        }
783                                                                       
784                                                                        switch ($l_type)
785                                                                        {
786                                                                                case 'email':
787                                                                                $contact_data['connections']['connection'.$i]['id_type'] = $preferences['personCardEmail'];
788                                                                                break;
789
790                                                                                default:
791                                                                                $contact_data['connections']['connection'.$i]['id_type'] = $preferences['personCardPhone'];
792                                                                        }
793                                                                        $contact_data['connections']['connection'.$i]['type'] = $l_type;
794                                                                        $contact_data['connections']['connection'.$i][$l_field] = utf8_decode($contact[$l_type_fields[0]][0]);
795                                                                        $i++;
796                                                                }
797                                                        }
798                                                        else
799                                                        {
800                                                                $contact_data['connections']['connection1'][$l_field] = utf8_decode($contact[$l_value[0]][0]);
801                                                        }
802                                                }
803                                               
804                                                if (!(count($contact_data['connections'])))
805                                                {
806                                                        unset($contact_data['connections']);
807                                                }
808                                                break;
809                                       
810                                        case 'prefix':
811                                                unset($l_fields);
812                                                $l_fields = $this->trans_table['contact.prefixes.prefix'];
813                                                if (!$l_fields or !$contact[$l_fields[0]][0])
814                                                {
815                                                        unset($contact_data['prefix']);
816                                                        continue;
817                                                }
818                                               
819                                                $contact_data['prefix'] = utf8_decode($contact[$l_fields[0]][0]);
820                                                break;
821                                               
822                                        case 'suffix':
823                                                unset($l_fields);
824                                                $l_fields = $this->trans_table['contact.suffixes.suffix'];
825                                                if (!$l_fields or !$contact[$l_fields[0]][0])
826                                                {
827                                                        unset($contact_data['suffix']);
828                                                        continue;
829                                                }
830                                               
831                                                $contact_data['suffix'] = utf8_decode($contact[$l_fields[0]][0]);
832                                                break;
833                                               
834                                        case 'status':
835                                                unset($l_fields);
836                                                $l_fields = $this->trans_table['contact.status.status_name'];
837                                                if (!$l_fields or !$contact[$l_fields[0]][0])
838                                                {
839                                                        unset($contact_data['status']);
840                                                        continue;
841                                                }
842                                               
843                                                $contact_data['status'] = utf8_decode($contact[$l_fields[0]][0]);
844                                                break;
845                                               
846                                                case 'photo':
847                                                unset($l_fields);
848                                                $l_fields = $this->trans_table['contact.photo'];
849                                                if (!$l_fields or !$contact[$l_fields[0]][0])
850                                                {
851                                                        unset($contact_data['photo']);
852                                                        continue;
853                                                }
854                                               
855                                                $contact_data['photo'] = $contact[$l_fields[0]][0];
856                                                break;                                                                                 
857
858                                        default:
859                                                unset($l_fields);
860                                                $l_fields = $this->trans_table['contact.'.$field];
861                                                if (!$l_fields or !$contact[$l_fields[0]][0])
862                                                {
863                                                        unset($contact_data[$field]);
864                                                        continue;
865                                                }
866                                               
867                                                if(count($contact[$l_fields[0]]) > 1)
868                                                {
869                                                        $tmp = array();
870                                                        foreach ($contact[$l_fields[0]] as $i => $j)
871                                                        {
872                                                                $tmp["$i"] = utf8_decode($j);
873                                                        }
874                                                        //$contact_data[$field] = $contact[$l_fields[0]];
875                                                        $contact_data[$field] = $tmp;
876                                                }
877                                                else
878                                                        $contact_data[$field] = utf8_decode($contact[$l_fields[0]][0]);
879
880                                                break;
881                                }
882                        }
883                       
884                        if (!is_array($contact_data))
885                        {
886                                return false;
887                        }
888                       
889                        return $contact_data;
890                }
891                //SERPRO
892                /*!
893
894                 @function get_all_entries
895                 @abstract Returns all information requested about a bunch of contacts, usually a page
896                 @author Raphael Derosso Pereira
897                 @author Mário César Kolling
898
899                 @param string $filter Filter (returned by generate_filter).
900                 @param array $fields The array returned by get_fields with true
901                        on the fields to be taken.
902
903                */
904                function get_all_entries($filter, $fields)
905                {
906                        if (!is_array($fields))
907                        {
908                                if (is_object($GLOBALS['phpgw']->log))
909                                {
910                                        $GLOBALS['phpgw']->log->message(array(
911                                                'text' => 'F-BadcontactcenterParam, wrong get_single_entry parameters type.',
912                                                'line' => __LINE__,
913                                                'file' => __FILE__));
914
915                                        $GLOBALS['phpgw']->log->commit();
916                                }
917                                else
918                                {
919                                        exit('Argument Error on: <br>File:'.__FILE__.'<br>Line:'.__LINE__.'<br>');
920                                }
921                        }
922
923                        $ldap = $GLOBALS['phpgw']->common->ldapConnect($this->src_info['host'],$this->src_info['acc'],$this->src_info['pw'],true);
924
925                        if (!$ldap)
926                        {
927                                return false;
928                        }
929
930                        $resource = @ldap_search($ldap, $this->src_info['dn'], $filter);
931                        $n_entries = @ldap_count_entries($ldap, $resource);
932
933                        ldap_sort($ldap, $resource, 'cn');
934
935                        if ( $n_entries < 1)
936                        {
937                                return false;
938                        }
939
940                        $contacts = array();
941
942                        for ($entry = ldap_first_entry($ldap, $resource);
943                                 $entry != false;
944                                 $entry = ldap_next_entry($ldap, $entry))
945                        {
946                                $contact = ldap_get_attributes($ldap,$entry);
947                                if($contact['jpegPhoto']){
948                                        $contact['jpegPhoto'] = ldap_get_values_len ($ldap, $entry, "jpegPhoto");
949                                }
950
951                                foreach($fields as $field => $trueness)
952                                {
953                                        if (!$trueness)
954                                        {
955                                                //unset($contact_data[$field]);
956                                                continue;
957                                        }
958
959                                        switch ($field)
960                                        {
961                                                case 'companies':
962                                                        unset($l_fields);
963                                                        $l_fields['company_name']  = $this->trans_table['contact.company.company_name'];
964                                                        $l_fields['title']         = $this->trans_table['contact.business_info.title'];
965                                                        $l_fields['department']    = $this->trans_table['contact.business_info.department'];
966                                                        $l_fields['company_notes'] = $this->trans_table['contact.company.company_notes'];
967
968                                                        //Relaciona o array com o atributo 'employeeNumber' do RHDS
969                                                        if(isset($_SESSION['phpgw_info']['user']['preferences']['contactcenter']['empNumberShow']) && $_SESSION['phpgw_info']['user']['preferences']['contactcenter']['empNumberShow'])
970                                                        {
971                                                                $l_fields['empNumber']     = $this->trans_table['contact.business_info.empNumber'];
972                                                        }
973                                                        //Relaciona o array com o atributo 'mobile' do RHDS
974                                                        $l_fields['celPhone']     = $this->trans_table['contact.business_info.celPhone'];
975
976                                                        //Relaciona o array com o atributo 'mobile' do RHDS
977                                                        $l_fields['celPhone']     = $this->trans_table['contact.business_info.celPhone'];
978
979                                                        $contact_data['companies'] = array();
980                                                        foreach($l_fields as $l_field => $l_value)
981                                                        {
982                                                                if (!( $contact[$l_value[0]][0]))
983                                                                {
984                                                                        continue;
985                                                                }
986
987                                                                $contact_data['companies']['company1'][$l_field] = utf8_decode($contact[$l_value[0]][0]);
988                                                        }
989
990                                                        if (!(count($contact_data['companies'])))
991                                                        {
992                                                                unset($contact_data['companies']);
993                                                        }
994                                                        break;
995
996                                                case 'relations':
997                                                        unset($l_fields);
998                                                        if (!$this->trans_table['contact.contact_related.names_ordered'])
999                                                        {
1000                                                                unset($contact_data['relations']);
1001                                                        }
1002
1003                                                        $contact_data['relations'] = array();
1004                                                        if (!is_array($this->trans_table['contact.contact_related.names_ordered']))
1005                                                        {
1006                                                                if (!($trans = $this->trans_table[$this->trans_table['contact.contact_related.names_ordered']]))
1007                                                                {
1008                                                                        continue;
1009                                                                }
1010
1011                                                                $i = 1;
1012                                                                foreach($trans as $l_type => $l_type_fields)
1013                                                                {
1014                                                                        if (!($contact[$l_type_fields[0]][0]))
1015                                                                        {
1016                                                                                continue;
1017                                                                        }
1018
1019                                                                        $contact_data['relations']['relation'.$i]['type'] = $l_type;
1020                                                                        $contact_data['relations']['relation'.$i]['names_ordered'] = utf8_decode($contact[$l_type_fields[0]][0]);
1021                                                                        $i++;
1022                                                                }
1023                                                        }
1024
1025                                                        if (!(count($contact_data['relations'])))
1026                                                        {
1027                                                                unset($contact_data['relations']);
1028                                                        }
1029                                                        break;
1030
1031                                                case 'addresses':
1032                                                        unset($l_fields);
1033                                                        $l_fields['address1'] = $this->trans_table['contact.address.address1'];
1034                                                        $l_fields['address2'] = $this->trans_table['contact.address.address2'];
1035                                                        $l_fields['complement'] = $this->trans_table['contact.address.complement'];
1036                                                        $l_fields['address_other'] = $this->trans_table['contact.address.address_other'];
1037                                                        $l_fields['postal_code'] = $this->trans_table['contact.address.postal_code'];
1038                                                        $l_fields['po_box'] = $this->trans_table['contact.address.po_box'];
1039                                                        $l_fields['id_city'] = $this->trans_table['contact.address.city.id_city'];
1040                                                        $l_fields['city_name'] = $this->trans_table['contact.address.city.city_name'];
1041                                                        $l_fields['city_timezone'] = $this->trans_table['contact.address.city.city_timezone'];
1042                                                        $l_fields['city_geo_location'] = $this->trans_table['contact.address.city.city_geo_location'];
1043                                                        $l_fields['id_state'] = $this->trans_table['contact.address.city.state.id_state'];
1044                                                        $l_fields['state_name'] = $this->trans_table['contact.address.city.state.state_name'];
1045                                                        $l_fields['state_symbol'] = $this->trans_table['contact.address.city.state.state_symbol'];
1046                                                        $l_fields['id_country'] = $this->trans_table['contact.address.city.country.id_country'];
1047                                                        $l_fields['country_name'] = $this->trans_table['contact.address.city.country.country_name'];
1048                                                        $l_fields['address_is_default'] = $this->trans_table['contact.address.address_is_default'];
1049
1050                                                        $contact_data['addresses'] = array();
1051                                                        foreach($l_fields as $l_field => $l_value)
1052                                                        {
1053                                                                if (!is_array($l_value))
1054                                                                {
1055                                                                        if (!($trans = $this->trans_table[$l_value]))
1056                                                                        {
1057                                                                                continue;
1058                                                                        }
1059
1060                                                                        $i = 1;
1061                                                                        foreach($trans as $l_type => $l_type_fields)
1062                                                                        {
1063                                                                                if (!($contact[$l_type_fields[0]][0]))
1064                                                                                {
1065                                                                                        continue;
1066                                                                                }
1067
1068                                                                                $contact_data['addresses']['address'.$i]['type'] = $l_type;
1069                                                                                $contact_data['addresses']['address'.$i][$l_field] = utf8_decode($contact[$l_type_fields[0]][0]);
1070                                                                                $i++;
1071                                                                        }
1072                                                                }
1073                                                                else
1074                                                                {
1075                                                                        $contact_data['addresses']['address1'][$l_field] = utf8_decode($contact[$l_value[0]][0]);
1076                                                                }
1077                                                        }
1078
1079                                                        if (!(count($contact_data['addresses'])))
1080                                                        {
1081                                                                unset($contact_data['addresses']);
1082                                                        }
1083                                                        break;
1084
1085                                                case 'connections':
1086                                    $preferences = ExecMethod('contactcenter.ui_preferences.get_preferences');
1087                                    if (!is_array($preferences))
1088                                    {
1089                                                                $preferences['personCardEmail'] = 1;
1090                                                                $preferences['personCardPhone'] = 2;
1091                                                        }
1092                                                        unset($l_fields);
1093                                                        $l_fields['connection_name'] = $this->trans_table['contact.connection.connection_name'];
1094                                                        $l_fields['connection_value'] = $this->trans_table['contact.connection.connection_value'];
1095
1096                                                        $contact_data['connections'] = array();
1097                                                        foreach($l_fields as $l_field => $l_value)
1098                                                        {
1099                                                                if (!is_array($l_value))
1100                                                                {
1101                                                                        if (!($trans = $this->trans_table[$l_value]))
1102                                                                        {
1103                                                                                continue;
1104                                                                        }
1105
1106                                                                        $i = 1;
1107                                                                        foreach($trans as $l_type => $l_type_fields)
1108                                                                        {
1109                                                                                if (!($contact[$l_type_fields[0]][0]))
1110                                                                                {
1111                                                                                        continue;
1112                                                                                }
1113
1114                                                                                switch ($l_type)
1115                                                                                {
1116                                                                                        case 'email':
1117                                                                                        $contact_data['connections']['connection'.$i]['id_type'] = $preferences['personCardEmail'];
1118                                                                                        break;
1119
1120                                                                                        default:
1121                                                                                        $contact_data['connections']['connection'.$i]['id_type'] = $preferences['personCardPhone'];
1122                                                                                }
1123                                                                                $contact_data['connections']['connection'.$i]['type'] = $l_type;
1124                                                                                $contact_data['connections']['connection'.$i][$l_field] = utf8_decode($contact[$l_type_fields[0]][0]);
1125                                                                                $i++;
1126                                                                        }
1127                                                                }
1128                                                                else
1129                                                                {
1130                                                                        $contact_data['connections']['connection1'][$l_field] = utf8_decode($contact[$l_value[0]][0]);
1131                                                                }
1132                                                        }
1133
1134                                                        if (!(count($contact_data['connections'])))
1135                                                        {
1136                                                                unset($contact_data['connections']);
1137                                                        }
1138                                                        break;
1139
1140                                                case 'prefix':
1141                                                        unset($l_fields);
1142                                                        $l_fields = $this->trans_table['contact.prefixes.prefix'];
1143                                                        if (!$l_fields or !$contact[$l_fields[0]][0])
1144                                                        {
1145                                                                unset($contact_data['prefix']);
1146                                                                continue;
1147                                                        }
1148
1149                                                        $contact_data['prefix'] = utf8_decode($contact[$l_fields[0]][0]);
1150                                                        break;
1151
1152                                                case 'suffix':
1153                                                        unset($l_fields);
1154                                                        $l_fields = $this->trans_table['contact.suffixes.suffix'];
1155                                                        if (!$l_fields or !$contact[$l_fields[0]][0])
1156                                                        {
1157                                                                unset($contact_data['suffix']);
1158                                                                continue;
1159                                                        }
1160
1161                                                        $contact_data['suffix'] = utf8_decode($contact[$l_fields[0]][0]);
1162                                                        break;
1163
1164                                                case 'status':
1165                                                        unset($l_fields);
1166                                                        $l_fields = $this->trans_table['contact.status.status_name'];
1167                                                        if (!$l_fields or !$contact[$l_fields[0]][0])
1168                                                        {
1169                                                                unset($contact_data['status']);
1170                                                                continue;
1171                                                        }
1172
1173                                                        $contact_data['status'] = utf8_decode($contact[$l_fields[0]][0]);
1174                                                        break;
1175
1176                                                        case 'photo':
1177                                                        unset($l_fields);
1178                                                        $l_fields = $this->trans_table['contact.photo'];
1179                                                        if (!$l_fields or !$contact[$l_fields[0]][0])
1180                                                        {
1181                                                                unset($contact_data['photo']);
1182                                                                continue;
1183                                                        }
1184
1185                                                        $contact_data['photo'] = $contact[$l_fields[0]][0];
1186                                                        break;
1187
1188                                                default:
1189                                                        unset($l_fields);
1190                                                        $l_fields = $this->trans_table['contact.'.$field];
1191                                                        if (!$l_fields or !$contact[$l_fields[0]][0])
1192                                                        {
1193                                                                unset($contact_data[$field]);
1194                                                                continue;
1195                                                        }
1196
1197                                                        if(count($contact[$l_fields[0]]) > 1)
1198                                                        {
1199                                                                $tmp = array();
1200                                                                foreach ($contact[$l_fields[0]] as $i => $j)
1201                                                                {
1202                                                                        $tmp["$i"] = utf8_decode($j);
1203                                                                }
1204                                                                //$contact_data[$field] = $contact[$l_fields[0]];
1205                                                                $contact_data[$field] = $tmp;
1206                                                        }
1207                                                        else
1208                                                                $contact_data[$field] = utf8_decode($contact[$l_fields[0]][0]);
1209
1210                                                        break;
1211
1212                                        }
1213                                }
1214
1215                                if (is_array($contact_data))
1216                                {
1217                                        $contacts[ldap_get_dn($ldap, $entry)] = $contact_data;
1218                                }
1219
1220                        }
1221
1222                        return $contacts;
1223                }
1224               
1225                function get_multiple_entries ( $id_contacts, $fields, $other_data = false, $external=false )
1226                {
1227                        if (!is_array($id_contacts) or !is_array($fields) or ($other_data != false and !is_array($other_data)))
1228                        {
1229                                if (is_object($GLOBALS['phpgw']->log))
1230                                {
1231                                        $GLOBALS['phpgw']->log->message(array(
1232                                                'text' => 'F-BadcontactcenterParam, wrong get_multiple_entry parameter type.',
1233                                                'line' => __LINE__,
1234                                                'file' => __FILE__));
1235                                       
1236                                        $GLOBALS['phpgw']->log->commit();
1237                                }
1238                                else {
1239                                        exit('Argument Error on: <br>File:'.__FILE__.'<br>Line:'.__LINE__.'<br>');
1240                                }
1241                        }
1242                         
1243                        foreach ($id_contacts as $id)
1244                        {
1245                                $contacts[$id] = $this->get_single_entry($id,$fields,$external);
1246                        }
1247                       
1248                        return $contacts;
1249
1250                        // SERPRO
1251                                               
1252                        /*$contacts = array();
1253       
1254                        if ($other_data)
1255                        {
1256                                //TODO
1257                        }
1258
1259                        $filter = $this->generate_filter($id_contacts);
1260
1261                        //$teste = $this->get_all_entries($filter, $fields);
1262
1263                        return $this->get_all_entries($filter, $fields);*/
1264                       
1265                }
1266
1267        // CELEPAR
1268                function generate_filter($id_contacts)
1269                {
1270                        if (($size = count($id_contacts)))
1271                        {
1272                                $contacts[$id] = $this->get_single_entry($id,$fields);
1273                        }
1274                       
1275                        return $contacts;
1276                }
1277               
1278                // SERPRO
1279                /*
1280                function generate_filter($id_contacts)
1281                {
1282                        if (($size = count($id_contacts)))
1283                        {
1284                                $filter = '(&(objectClass='.$this->src_info['obj'] .  ')(|';
1285                                for ($i = 0; $i < $size; $i++)
1286                                {
1287
1288                                        //
1289                                        //  Não utiliza mais a função ldap_explode, usa a expressão regular a seguir para pegar o primeiro
1290                                        //  componente da dn
1291                                        //
1292                                        preg_match('/^(\w*=[^,]*),.*$/', $id_contacts[$i], $cn);
1293
1294                                //
1295                                // Adicionados os str_replace para adicionar caracteres de escape em frente aos caracteres '(' e ')',
1296                                // posteriormente poderá ser necessário substituir por uma expressão regular mais genérica.
1297                                //
1298
1299                                        if ($cn[1])
1300                                        {
1301                                                //
1302                                                // Esta operação resolve o problema causado pela conversão de caracteres acentuados realizada
1303                                                // pela função ldap_explode_dn(). Talvez seja necessário utilizar esta tradução em outros lugares,
1304                                                // neste caso é mais apropriado colocar dentro de uma função.
1305                                                //
1306                                                //foreach($cn as $key=>$value){
1307                                        //      $cn[$key]=preg_replace("/\\\([0-9A-Fa-f]{2})/e", "''.chr(hexdec('\\1')).''", $value);
1308                                        //}
1309
1310                                                $filter .= '(' . str_replace(')', '\)', str_replace('(','\(',$cn[1])) . ')';
1311                                        }
1312                                }
1313                                $filter .= '))';
1314                        }
1315
1316                        return $filter;
1317
1318                }
1319                */
1320
1321                function get_all_entries_ids ()
1322                {
1323                        $search_fields = array('contact.id_contact', 'contact.names_ordered');
1324                        $search_rules  = array(
1325                                0 => array(
1326                                        'field' => 'contact.names_ordered',
1327                                        'type'  => 'LIKE',
1328                                        'value' => '%'
1329                                )
1330                        );
1331                        $search_other  = array('order' => 'contact.names_ordered');
1332
1333                        $result_i = $this->find($search_fields, $search_rules, $search_other);
1334
1335                        if (is_array($result_i) and count($result_i))
1336                        {
1337                                $result = array();
1338                                foreach($result_i as $result_part)
1339                                {
1340                                        $result[] = $result_part['id_contact'];
1341                                }
1342
1343                                return $result;
1344                        }
1345
1346                        return null;
1347                }
1348               
1349                function get_relations ($id_contact,$extra=false)
1350                {
1351                }
1352               
1353                function get_addresses ( $id_contact,$extra=false )
1354                {
1355                }
1356               
1357                function get_connections ( $id_contact,$extra=false )
1358                {
1359                }
1360               
1361                function get_companies ( $id_contact, $extra=false )
1362                {
1363                }
1364               
1365                function get_all_prefixes (  )
1366                {
1367                }
1368               
1369                function get_all_suffixes (  )
1370                {
1371                }
1372               
1373                function get_all_status (  )
1374                {
1375                }
1376               
1377                function get_all_relations_types (  )
1378                {
1379                }
1380               
1381                function get_all_addresses_types (  )
1382                {
1383                }
1384               
1385                function get_all_connections_types (  )
1386                {
1387                }
1388               
1389                function get_vcard ( $id_contact )
1390                {
1391                }
1392               
1393               
1394               
1395               
1396                function get_global_tree ( $root )
1397                {
1398                }
1399       
1400                function get_actual_brach (  )
1401                {
1402                }
1403       
1404                function set_actual_branch ( $branch )
1405                {
1406                }
1407        }
1408?>
Note: See TracBrowser for help on using the repository browser.