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

Revision 795, 14.4 KB checked in by viani, 15 years ago (diff)

Ticket #488 - Inclusão do módulo workflow no ramo trunk do repositório 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 = $GLOBALS['workflow']['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);
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 = &$GLOBALS['workflow']['workflowObjects']->getDBExpresso();
204                        $GLOBALS['phpgw']->acl = &$GLOBALS['workflow']['factory']->getForeignInstance('phpgwapi', '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        * @return bool
314        * @access public
315        */
316        function getUserPermissions($type, $uid)
317        {
318                $query = "
319                        SELECT
320                                numvalue
321                        FROM
322                                egw_wf_admin_access
323                         WHERE
324                                (tipo = ?) AND
325                                (admin_access_id = ?)";
326
327                $result = $this->db->query($query, array($type, $uid));
328
329                $output = array();
330                if ($result)
331                        while ($row = $result->fetchRow())
332                                $output[] = $row['numvalue'];
333
334                return $output;
335        }
336        /**
337         * Retorna as permissoes do grupo do usuário
338         *
339         * @param string $type
340         * @param integer $uid id do usuário
341         * @access public
342         * @return array
343         */
344        function getUserGroupPermissions($type, $uid)
345        {
346                $groups = galaxia_retrieve_user_groups($uid);
347                if ($groups === false)
348                        $groups = array();
349
350                $query = "
351                        SELECT
352                                DISTINCT(numvalue) AS numvalue
353                        FROM
354                                egw_wf_admin_access
355                         WHERE
356                                (tipo = ?) AND
357                                (admin_access_id IN (" . implode(', ', array_merge(array($uid), $groups)) . "))";
358
359                $result = $this->db->query($query, array($type));
360
361                $output = array();
362                if ($result)
363                        while ($row = $result->fetchRow())
364                                $output[] = $row['numvalue'];
365
366                return $output;
367        }
368        /**
369        * Verifica se o usuario tem acesso a um tipo de recurso
370        *
371        * @param string $type type of resource
372        * @param integer $uid user id
373        * @return bool
374        * @access public
375        */
376        function checkUserAccessToType($type, $uid)
377        {
378                return (count($this->getUserPermissions($type, $uid)) > 0);
379        }
380        /**
381        * Verifica se o grupo do usuario tem acesso a um tipo de recurso
382        *
383        * @param string $type type of resource
384        * @param integer $uid user id
385        * @return bool
386        * @access public
387        */
388        function checkUserGroupAccessToType($type, $uid)
389        {
390                return (count($this->getUserGroupPermissions($type, $uid)) > 0);
391        }
392
393        /**
394        * Verifica se o usuário tem direito de acesso a um recurso
395        *
396        * @param string $type tipo de recurso
397        * @param integer $uid id do usuário
398        * @param integer $numvalue id do recurso
399        * @param array  $requiredLevel permissoes requeridas
400        * @return bool
401        * @access public
402        */
403        function checkUserAccessToResource($type, $uid, $numvalue, $requiredLevel = null)
404        {
405                $query = "
406                        SELECT
407                                nivel
408                        FROM
409                                egw_wf_admin_access
410                         WHERE
411                                (tipo = ?) AND
412                                (admin_access_id = ?) AND
413                                (numvalue = ?)";
414
415                $result = $this->db->query($query, array($type, $uid, $numvalue));
416                $row = $result->fetchRow();
417
418                if (isset($row['nivel']))
419                        return $this->_checkLevelNumber($row['nivel'], $requiredLevel);
420                else
421                        return false;
422        }
423        /**
424        * Verifica se o grupo do usuário tem direito de acesso a um recurso
425        *
426        * @param string $type tipo de recurso
427        * @param integer $uid id do usuário
428        * @param integer $numvalue id do recurso
429        * @param array  $requiredLevel permissoes requeridas
430        * @return bool
431        * @access public
432        */
433        function checkUserGroupAccessToResource($type, $uid, $numvalue, $requiredLevel = null)
434        {
435                $groups = galaxia_retrieve_user_groups($uid);
436                if ($groups === false)
437                        $groups = array();
438
439                $query = "
440                        SELECT
441                                nivel
442                        FROM
443                                egw_wf_admin_access
444                         WHERE
445                                (tipo = ?) AND
446                                (admin_access_id IN (" . implode(', ', array_merge(array($uid), $groups)) . ")) AND
447                                (numvalue = ?)";
448
449                $levels = array();
450                $permissions = 0;
451                $result = $this->db->query($query, array($type, $numvalue));
452                while ($row = $result->fetchRow())
453                {
454                        $levels[] = $row['nivel'];
455                        $permissions |= $row['nivel'];
456                }
457
458                if (empty($levels))
459                        return false;
460                else
461                        return $this->_checkLevelNumber($permissions, $requiredLevel);
462        }
463
464        /**
465        * Adiciona um administrador
466        *
467        * @param string  $type tipo de recurso
468        * @param array   $uids
469        * @param integer $numvalue id do recurso
470        * @param array   $level nivel de permissao do usuario
471        * @return void
472        * @access public
473        */
474        function addAdmin($type, $uids, $numvalue, $level = 0)
475        {
476                if (!is_array($uids))
477                        $uids = array($uids);
478                if (is_array($level))
479                        $level = $this->_permissionListToNumber($level);
480                foreach($uids as $uid)
481                {
482                        $query = "
483                                INSERT INTO egw_wf_admin_access
484                                        (admin_access_id,
485                                        tipo,
486                                        numvalue,
487                                        nivel)
488                                VALUES (?, ?, ?, ?)";
489                        $this->db->query($query, array($uid, $type, $numvalue, $level));
490                }
491        }
492        /**
493        * Setaa o nivel de administracao
494        *
495        * @param string  $type tipo de recurso
496        * @param integer $uid id do usuário
497        * @param integer $numvalue id do recurso
498        * @param array   $level permissoes requeridas
499        * @return void
500        * @access public
501        */
502        function setAdminLevel($type, $uid, $numvalue, $level)
503        {
504                if (is_array($level))
505                        $level = $this->_permissionListToNumber($level);
506
507                $query = "
508                        UPDATE egw_wf_admin_access
509                        SET
510                                nivel = ?
511                        WHERE
512                                (admin_access_id = ?) AND
513                                (tipo = ?) AND
514                                (numvalue = ?)";
515                $this->db->query($query, array($level, $uid, $type, $numvalue));
516        }
517
518        /**
519        * Informa o nível de administração do usuário
520        * @param string $type O tipo do recurso
521        * @param int $uid O ID do usuário
522        * @param int $numvalue O ID do recurso
523        * @return array As permissões do usuário (em forma de número e de bits)
524        * @access public
525        */
526        function getUserAdminLevel($type, $uid, $numvalue)
527        {
528                $query = "
529                        SELECT
530                                nivel
531                        FROM
532                                egw_wf_admin_access
533                         WHERE
534                                (tipo = ?) AND
535                                (admin_access_id = ?) AND
536                                (numvalue = ?)";
537
538                $result = $this->db->query($query, array($type, $uid, $numvalue));
539
540                $row = $result->fetchRow();
541                if (isset($row['nivel']))
542                {
543                        $output['number'] = $row['nivel'];
544                        $output['bits'] = $this->_numberToPermissionList($row['nivel']);
545                        return $output;
546                }
547                else
548                        return false;
549        }
550
551        /**
552        * Informa o nível de administração do usuário (incluindo herança por grupo)
553        * @param string $type O tipo do recurso
554        * @param int $uid O ID do usuário
555        * @param int $numvalue O ID do recurso
556        * @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
557        * @access public
558        */
559        function getUserGroupAdminLevel($type, $uid, $numvalue)
560        {
561                /* prepare the group information */
562                $groups = galaxia_retrieve_user_groups($uid);
563                if ($groups === false)
564                        $groups = array();
565                $groups[] = $uid;
566        $groups = '{' . implode(', ', $groups) . '}';
567
568                $query = "
569                        SELECT
570                                nivel
571                        FROM
572                                egw_wf_admin_access
573                         WHERE
574                                (tipo = ?) AND
575                                (admin_access_id = ANY (?)) AND
576                                (numvalue = ?)";
577
578                $result = $this->db->query($query, array($type, $groups, $numvalue));
579
580                $levels = array();
581                $permissions = 0;
582                while ($row = $result->fetchRow())
583                {
584                        $permissions |= $row['nivel'];
585                        $levels[] = $row['nivel'];
586                }
587
588                if (count($levels) > 0)
589                {
590                        return array(
591                                'number' => $permissions,
592                                'bits' => $this->_numberToPermissionList($permissions));
593                }
594                else
595                        return false;
596        }
597
598        /**
599        * Remove administrador(es)
600        *
601        * @param string  $type tipo de recurso
602        * @param integer $uids id(s) do(s) usuário(s)
603        * @param integer $numvalue id do recurso
604        * @return void
605        * @access public
606        */
607        function removeAdmin($type, $uids, $numvalue)
608        {
609                if (!is_array($uids))
610                        $uids = array($uids);
611                foreach($uids as $uid)
612                {
613                        $query = "
614                                DELETE FROM
615                                        egw_wf_admin_access
616                                WHERE
617                                        (tipo = ?) AND
618                                        (numvalue = ?) AND
619                                        (admin_access_id = ?)";
620
621                        $result = $this->db->query($query, array($type, $numvalue, $uid));
622                }
623        }
624        /**
625        * Remove todos os administradores de um recurso
626        *
627        * @param string  $type tipo de recurso
628        * @param integer $numvalue id do recurso
629        * @return void
630        * @access public
631        */
632        function removeAdminsFromResource($type, $numvalue)
633        {
634                $query = "
635                        DELETE FROM
636                                egw_wf_admin_access
637                        WHERE
638                                (tipo = ?) AND
639                                (numvalue = ?)";
640
641                $result = $this->db->query($query, array($type, $numvalue));
642        }
643}
644
645?>
Note: See TracBrowser for help on using the repository browser.