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

Revision 3136, 39.2 KB checked in by niltonneto, 14 years ago (diff)

Ticket #1115 - Corrigido problema de pesquisa sem resultado encontrado.

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