source: branches/1.2/contactcenter/inc/class.bo_global_ldap_catalog.inc.php @ 400

Revision 400, 35.3 KB checked in by niltonneto, 16 years ago (diff)

Corrigido comentários com problema de charset.

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