source: trunk/workflow/inc/class.so_adminaccess.inc.php @ 7655

Revision 7655, 15.1 KB checked in by douglasz, 11 years ago (diff)

Ticket #3236 - Melhorias de performance no codigo do Expresso.
  • Property svn:executable set to *
Line 
1<?php
2/**************************************************************************\
3* eGroupWare                                                               *
4* http://www.egroupware.org                                                *
5* --------------------------------------------                             *
6*  This program is free software; you can redistribute it and/or modify it *
7*  under the terms of the GNU General Public License as published by the   *
8*  Free Software Foundation; either version 2 of the License, or (at your  *
9*  option) any later version.                                              *
10\**************************************************************************/
11
12/**
13 * Realiza operações de acl e organograma no banco de dados e ldap
14 *
15 * @package Workflow
16 * @class so_adminaccess
17 * @private
18 * @author Sidnei Augusto Drovetto Junior - drovetto@gmail.com
19 * @author Rodrigo Daniel C de Lira - rodrigo.lira@gmail.com
20 * @license http://www.gnu.org/copyleft/gpl.html GPL
21 */
22class so_adminaccess
23{
24        /**
25        * Objeto do banco de dados (conectado)
26        *
27        * @var object $db
28        * @access public
29        */
30        var $db;
31
32        private $numberOfPermissions = 32;
33
34        /**
35        * Recebe objeto do banco de dados e armazena como atributo da classe.
36        *
37        * @return void
38        * @access public
39        */
40        function so_adminaccess($db)
41        {
42                $this->db = $db;
43        }
44
45        /**
46        * Obtém a lista de administradores de um processo
47        *
48        * @param integer $proc_id
49        * @return array
50        * @access public
51        */
52        function get_process_admins_id($proc_id)
53        {
54                return $this->getResourceAdmins('PRO', $proc_id);
55        }
56
57        /**
58        * Obtém a lista de administradores do organograma de uma organização
59        *
60        * @param integer $org
61        * @return array
62        * @access public
63        */
64        function get_organogram_admins_id($org)
65        {
66                return $this->getResourceAdmins('ORG', $org);
67        }
68
69        /**
70        * Obtém os atributos cn e uidNumber, no ldap, para uma lista de usuários
71        *
72        * @param array $userIDs Os IDs dos usuários/grupos
73        * @return array Uma array contendo os IDs e nomes que foram encontrados
74        * @access public
75        */
76        function getUserNames($userIDs)
77        {
78                $output = array();
79                $names = Factory::getInstance('WorkflowLDAP')->getNames($userIDs);
80                foreach ($names as $name)
81                        $output[] = array(
82                                'cn' => $name['name'],
83                                'uidnumber' => $name['id']);
84                return $output;
85    }
86
87        /**
88        * Remove o administrador de um organograma
89        *
90        * @param integer $org_id
91        * @param integer $admin_id
92        * @return void
93        * @access public
94        */
95        function del_organogram_admin($org_id,$admin_id)
96        {
97                $this->removeAdmin('ORG', $admin_id, $org_id);
98        }
99
100        /**
101        * Remove o administrador de um processo
102        *
103        * @param integer $proc_id
104        * @param integer $admin_id
105        * @return void
106        * @access public
107        */
108        function del_process_admin($proc_id,$admin_id)
109        {
110                $this->removeAdmin('PRO', $admin_id, $proc_id);
111        }
112
113        /**
114        * Remove todos os administradores de um processo
115        *
116        * @param integer $proc_id
117        * @return void
118        * @access public
119        */
120        function del_process($proc_id)
121        {
122                $this->removeAdminsFromResource('PRO', $proc_id);
123        }
124
125
126        /**
127        * Insere administradores de organograma
128        *
129        * @param integer $org_id
130        * @param array $ids
131        * @return void
132        * @access public
133        */
134        function add_organogram_admins($org_id,$ids)
135        {
136                $this->addAdmin('ORG', $ids, $org_id);
137        }
138
139        /**
140        * Insere administradores de um processo
141        *
142        * @param integer $proc_id
143        * @param integer $ids
144        * @return void
145        * @access public
146        */
147        function add_process_admins($proc_id,$ids)
148        {
149                $this->addAdmin('PRO', $ids, $proc_id);
150        }
151
152        /**
153        * Verifica se um usuário pode administrar um processo
154        *
155        * @param integer $user_id
156        * @param integer $proc_id
157        * @return array
158        * @access public
159        */
160        function check_process_access($user_id,$proc_id)
161        {
162                return $this->checkUserGroupAccessToResource('PRO', $user_id, $proc_id);
163        }
164
165                /**
166        * Obtém os processos permitidos para um usuário
167        *
168        * @param integer $user_id
169        * @return array
170        * @access public
171        */
172        function get_granted_processes($user_id)
173        {
174                return $this->getUserGroupPermissions('PRO', $user_id);
175        }
176
177        /**
178        * Obtém os organogramas permitidos para um usuário
179        *
180        * @param integer $user_id
181        * @return array
182        * @access public
183        */
184        function get_granted_organograms($user_id)
185        {
186                return $this->getUserPermissions('ORG', $user_id, 0);
187        }
188
189        /**
190        * Indica se um usuário é administrador do Workflow ou não.
191        *
192        * @param int $userID O ID do usuário
193        * @return bool true se o usuário é um administrador do Workflow (ou do Expresso) ou false caso contrário
194        * @access public
195        */
196        function checkWorkflowAdmin($userID)
197        {
198                if ($this->checkUserGroupAccessToType('ADM', $userID) === true)
199                        return true;
200
201                if (!is_object($GLOBALS['phpgw']->acl))
202                {
203                        $GLOBALS['phpgw']->db =& Factory::getInstance('WorkflowObjects')->getDBExpresso();
204                        $GLOBALS['phpgw']->acl =& Factory::getInstance('acl', $userID);
205                }
206
207                if (is_object($GLOBALS['phpgw']->acl))
208                        if ($GLOBALS['phpgw']->acl->check('run', 1, 'admin') === true)
209                                return true;
210
211                return false;
212        }
213
214        /**
215        * Obtém a lista de permissoes equivalente ao numero decimal passado como parametro
216        *
217        * @param integer $number
218        * @return array
219        * @access public
220        */
221        function _numberToPermissionList($number)
222        {
223                /* prepare the permission list*/
224                $levelList = array_fill(0, $this->numberOfPermissions, false);
225
226                $tmpBin = decbin($number);
227                $tmpSize = strlen($tmpBin);
228                for ($i = 0; $i < $tmpSize; ++$i)
229                        $levelList[$tmpSize - $i - 1] = ($tmpBin[$i] == '0') ? false : true;
230
231                return $levelList;
232        }
233        /**
234        * Converte uma lista de permissoes para um numero inteiro que a representa
235        *
236        * @param string $list
237        * @return integer
238        * @access public
239        */
240        function _permissionListToNumber($list)
241        {
242                if (is_numeric($list))
243                        return (int) $list;
244
245                $text = "";
246                for ($i = 0; $i < $this->numberOfPermissions; ++$i)
247                        if (isset($list[$i]))
248                                $text = (($list[$i] == true) ? '1' : '0') . $text;
249                        else
250                                $text = "0" . $text;
251
252                return bindec($text);
253        }
254
255        /**
256        * Verifica se o numero passado representa todas as permissoes requeridas
257        *
258        * @param integer $number Número que representa uma lista de permissões
259        * @param array $required Permissões requeridas
260        * @return boolean
261        * @access public
262        */
263        function _checkLevelNumber($number, $required)
264        {
265                if (is_null($required))
266                        return true;
267                if (!is_array($required))
268                        $required = array($required);
269
270                $levelList = $this->_numberToPermissionList($number);
271
272                /* check for the required permissions */
273                foreach ($required as $req)
274                        if (!$levelList[$req])
275                                return false;
276
277                return true;
278        }
279
280        /**
281        * Retorna os recursos disponiveis ao Administrador
282        *
283        * @param string $type type of resource
284        * @param integer $numvalue resource id
285        * @return array
286        * @access public
287        */
288        function getResourceAdmins($type, $numvalue)
289        {
290                $query = "
291                        SELECT
292                                admin_access_id
293                        FROM
294                                egw_wf_admin_access
295                         WHERE
296                                (tipo = ?) AND
297                                (numvalue = ?)";
298
299                $result = $this->db->query($query, array($type, $numvalue));
300
301                $output = array();
302                while ($row = $result->fetchRow())
303                        $output[] = $row['admin_access_id'];
304
305                return $output;
306        }
307
308        /**
309        * Verifica se o usuario tem acesso a um tipo de recurso
310        *
311        * @param string $type type of resource
312        * @param integer $uid user id
313        * @param requiredLevel Level Required to Access.
314        * @return bool
315        * @access public
316        */
317        function getUserPermissions($type, $uid, $requiredLevel = null)
318        {
319                $query = "
320                        SELECT
321                                numvalue,
322                                nivel
323                        FROM
324                                egw_wf_admin_access
325                         WHERE
326                                (tipo = ?) AND
327                                (admin_access_id = ?)";
328
329                $result = $this->db->query($query, array($type, $uid));
330
331                $output = array();
332                if ($result)
333                        while ($row = $result->fetchRow()) {
334                                $authorized = $this->_checkLevelNumber($row['nivel'], $requiredLevel);
335                                if (isset($requiredLevel)) {
336                                        $authorized = $this->checkUserAccessToResource($type,$uid,$row['numvalue'],$requiredLevel);
337                                        if ($authorized) {
338                                                $output[] = $row['numvalue'];
339                                        }
340                                } else {
341                                        $output[] = $row['numvalue'];
342                                }
343                        }
344
345                return $output;
346        }
347        /**
348         * Retorna as permissoes do grupo do usuário
349         *
350         * @param string $type
351         * @param integer $uid id do usuário
352         * @access public
353         * @return array
354         */
355        function getUserGroupPermissions($type, $uid, $requiredLevel = null)
356        {
357                $groups = galaxia_retrieve_user_groups($uid);
358                if ($groups === false)
359                        $groups = array();
360
361                $query = "
362                        SELECT
363                                DISTINCT(numvalue) AS numvalue
364                        FROM
365                                egw_wf_admin_access
366                         WHERE
367                                (tipo = ?) AND
368                                (admin_access_id IN (" . implode(', ', array_merge(array($uid), $groups)) . "))";
369
370                $result = $this->db->query($query, array($type));
371
372                $output = array();
373                if ($result)
374                        while ($row = $result->fetchRow()) {
375                                if (isset($requiredLevel)) {
376                                        //$authorized = $this->_checkLevelNumber($row['nivel'], $requiredLevel);
377                                        $authorized = $this->checkUserGroupAccessToResource($type,$uid,$row['numvalue'],$requiredLevel);
378                                        if ($authorized) {
379                                                $output[] = $row['numvalue'];
380                                        }
381                                } else {
382                                        $output[] = $row['numvalue'];
383                                }
384                        }
385
386                return $output;
387        }
388        /**
389        * Verifica se o usuario tem acesso a um tipo de recurso
390        *
391        * @param string $type type of resource
392        * @param integer $uid user id
393        * @return bool
394        * @access public
395        */
396        function checkUserAccessToType($type, $uid)
397        {
398                return (count($this->getUserPermissions($type, $uid,0)) > 0);
399        }
400        /**
401        * Verifica se o grupo do usuario tem acesso a um tipo de recurso
402        *
403        * @param string $type type of resource
404        * @param integer $uid user id
405        * @return bool
406        * @access public
407        */
408        function checkUserGroupAccessToType($type, $uid)
409        {
410                return (count($this->getUserGroupPermissions($type, $uid)) > 0);
411        }
412
413        /**
414        * Verifica se o usuário tem direito de acesso a um recurso
415        *
416        * @param string $type tipo de recurso
417        * @param integer $uid id do usuário
418        * @param integer $numvalue id do recurso
419        * @param array  $requiredLevel permissoes requeridas
420        * @return bool
421        * @access public
422        */
423        function checkUserAccessToResource($type, $uid, $numvalue, $requiredLevel = null)
424        {
425                $query = "
426                        SELECT
427                                nivel
428                        FROM
429                                egw_wf_admin_access
430                         WHERE
431                                (tipo = ?) AND
432                                (admin_access_id = ?) AND
433                                (numvalue = ?)";
434
435                $result = $this->db->query($query, array($type, $uid, $numvalue));
436               
437                $row = $result->fetchRow();
438
439                if (isset($row['nivel'])) {
440                        $res = $this->_checkLevelNumber($row['nivel'], $requiredLevel);         
441                        return $res;
442                }
443                else
444                        return false;
445        }
446        /**
447        * Verifica se o grupo do usuário tem direito de acesso a um recurso
448        *
449        * @param string $type tipo de recurso
450        * @param integer $uid id do usuário
451        * @param integer $numvalue id do recurso
452        * @param array  $requiredLevel permissoes requeridas
453        * @return bool
454        * @access public
455        */
456        function checkUserGroupAccessToResource($type, $uid, $numvalue, $requiredLevel = null)
457        {
458                $groups = galaxia_retrieve_user_groups($uid);
459                if ($groups === false)
460                        $groups = array();
461
462                $query = "
463                        SELECT
464                                nivel
465                        FROM
466                                egw_wf_admin_access
467                         WHERE
468                                (tipo = ?) AND
469                                (admin_access_id IN (" . implode(', ', array_merge(array($uid), $groups)) . ")) AND
470                                (numvalue = ?)";
471
472                $levels = array();
473                $permissions = 0;
474                $result = $this->db->query($query, array($type, $numvalue));
475                while ($row = $result->fetchRow())
476                {
477                        $levels[] = $row['nivel'];
478                        $permissions |= $row['nivel'];
479                }
480
481                if (empty($levels))
482                        return false;
483                else
484                        return $this->_checkLevelNumber($permissions, $requiredLevel);
485        }
486
487        /**
488        * Adiciona um administrador
489        *
490        * @param string  $type tipo de recurso
491        * @param array   $uids
492        * @param integer $numvalue id do recurso
493        * @param array   $level nivel de permissao do usuario
494        * @return void
495        * @access public
496        */
497        function addAdmin($type, $uids, $numvalue, $level = 0)
498        {
499                if (!is_array($uids))
500                        $uids = array($uids);
501                if (is_array($level))
502                        $level = $this->_permissionListToNumber($level);
503                foreach($uids as $uid)
504                {
505                        $query = "
506                                INSERT INTO egw_wf_admin_access
507                                        (admin_access_id,
508                                        tipo,
509                                        numvalue,
510                                        nivel)
511                                VALUES (?, ?, ?, ?)";
512                        $this->db->query($query, array($uid, $type, $numvalue, $level));
513                }
514        }
515        /**
516        * Seta o nivel de administracao
517        *
518        * @param string  $type tipo de recurso
519        * @param integer $uid id do usuário
520        * @param integer $numvalue id do recurso
521        * @param array   $level permissoes requeridas
522        * @return void
523        * @access public
524        */
525        function setAdminLevel($type, $uid, $numvalue, $level)
526        {
527                if (is_array($level))
528                        $level = $this->_permissionListToNumber($level);
529
530                $query = "UPDATE egw_wf_admin_access
531                        SET
532                                nivel = ?
533                        WHERE
534                                (admin_access_id = ?) AND
535                                (tipo = ?) AND
536                                (numvalue = ?)";
537                $result = $this->db->query($query, array($level, $uid, $type, $numvalue));
538               
539                return $result;
540        }
541
542        /**
543        * Informa o nível de administração do usuário
544        * @param string $type O tipo do recurso
545        * @param int $uid O ID do usuário
546        * @param int $numvalue O ID do recurso
547        * @return array As permissões do usuário (em forma de número e de bits)
548        * @access public
549        */
550        function getUserAdminLevel($type, $uid, $numvalue)
551        {
552                $query = "
553                        SELECT
554                                nivel
555                        FROM
556                                egw_wf_admin_access
557                         WHERE
558                                (tipo = ?) AND
559                                (admin_access_id = ?) AND
560                                (numvalue = ?)";
561
562                $result = $this->db->query($query, array($type, $uid, $numvalue));
563
564                $row = $result->fetchRow();
565                if (isset($row['nivel']))
566                {
567                        $output['number'] = $row['nivel'];
568                        $output['bits'] = $this->_numberToPermissionList($row['nivel']);
569                        return $output;
570                }
571                else
572                        return false;
573        }
574
575        /**
576        * Informa o nível de administração do usuário (incluindo herança por grupo)
577        * @param string $type O tipo do recurso
578        * @param int $uid O ID do usuário
579        * @param int $numvalue O ID do recurso
580        * @return array As permissões do usuário, inclusive herança por grupo. As permissões são retornadas em forma de número e de bits
581        * @access public
582        */
583        function getUserGroupAdminLevel($type, $uid, $numvalue)
584        {
585                /* prepare the group information */
586                $groups = galaxia_retrieve_user_groups($uid);
587                if ($groups === false)
588                        $groups = array();
589                $groups[] = $uid;
590        $groups = '{' . implode(', ', $groups) . '}';
591
592                $query = "
593                        SELECT
594                                nivel
595                        FROM
596                                egw_wf_admin_access
597                         WHERE
598                                (tipo = ?) AND
599                                (admin_access_id = ANY (?)) AND
600                                (numvalue = ?)";
601
602                $result = $this->db->query($query, array($type, $groups, $numvalue));
603
604                $levels = array();
605                $permissions = 0;
606                while ($row = $result->fetchRow())
607                {
608                        $permissions |= $row['nivel'];
609                        $levels[] = $row['nivel'];
610                }
611
612                if (count($levels) > 0)
613                {
614                        return array(
615                                'number' => $permissions,
616                                'bits' => $this->_numberToPermissionList($permissions));
617                }
618                else
619                        return false;
620        }
621
622        /**
623        * Remove administrador(es)
624        *
625        * @param string  $type tipo de recurso
626        * @param integer $uids id(s) do(s) usuário(s)
627        * @param integer $numvalue id do recurso
628        * @return void
629        * @access public
630        */
631        function removeAdmin($type, $uids, $numvalue)
632        {
633                if (!is_array($uids))
634                        $uids = array($uids);
635                foreach($uids as $uid)
636                {
637                        $query = "
638                                DELETE FROM
639                                        egw_wf_admin_access
640                                WHERE
641                                        (tipo = ?) AND
642                                        (numvalue = ?) AND
643                                        (admin_access_id = ?)";
644
645                        $result = $this->db->query($query, array($type, $numvalue, $uid));
646                }
647        }
648        /**
649        * Remove todos os administradores de um recurso
650        *
651        * @param string  $type tipo de recurso
652        * @param integer $numvalue id do recurso
653        * @return void
654        * @access public
655        */
656        function removeAdminsFromResource($type, $numvalue)
657        {
658                $query = "
659                        DELETE FROM
660                                egw_wf_admin_access
661                        WHERE
662                                (tipo = ?) AND
663                                (numvalue = ?)";
664
665                $result = $this->db->query($query, array($type, $numvalue));
666        }
667}
668
669?>
Note: See TracBrowser for help on using the repository browser.