source: branches/2.3/contactcenter/inc/class.bo_global_ldap_catalog.inc.php @ 5107

Revision 5107, 39.0 KB checked in by rafaelraymundo, 13 years ago (diff)

Ticket #2286 - Adicionado modulo acessivel ao Expresso.

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