source: branches/2.2/contactcenter/inc/class.bo_global_ldap_catalog.inc.php @ 3211

Revision 3211, 39.3 KB checked in by niltonneto, 14 years ago (diff)

Ticket #1185 - Corrigido erro ao listar OU com muitos objetos dentro do Catálogo Geral.

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