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

Revision 5399, 41.5 KB checked in by cristiano, 12 years ago (diff)

Ticket #2434 - Alteração da estrutura de diretórios da nova API

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