source: sandbox/2.2.0.2/contactcenter/inc/class.bo_global_ldap_catalog.inc.php @ 4538

Revision 4538, 40.6 KB checked in by airton, 13 years ago (diff)

Ticket #1934 - Parametrização das buscas LDAP no Contactcenter

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