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

Revision 4838, 41.2 KB checked in by airton, 13 years ago (diff)

Ticket #2150 - Melhorias nas buscas no catalogo global

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