File Source for perms.classe.php

<?
/**
* permissoes.classe.php
*
* Esta classe inicializa as informações de permissões e retorna a permissão ou não de determinado
* recurso dados o recurso (ucase) e o ator
*
* @filesource
* @package Soomp
* @author Marcio Merlone <mmerlone@gmail.com>
* @version 1.0
* @since 31/08/2006
* @copyright 2008 Soomp
*/
/* $Id: perms.classe.php,v 1.1 2007/05/24 20:21:58 mmerlone Exp $ */
require_once(CFG_LOCAL_FRAMEWORK.'stdio.classe.php');
require_once(CFG_LOCAL_FRAMEWORK.'usuario.classe.php');
require_once(CFG_LOCAL_FRAMEWORK.'grupo.classe.php');
/**
* Classe de permissões de acesso
*
* As permissões são calculadas baseando-se nas informações:
* - (bitsUser) Grupos do usuário $objUser->grupos (array de objetos de grupo)
* - (bitsActions) Bits de permissão do módulo definidas em $req->objConfig->actions
* - (bitsPerm) Bits de permissão de grupos armazenadas em $req->objConfig->permissions
* ou no banco de dados:
* <code>
* CREATE TABLE `TB_PERMS` (
* `PK_PERM` int(11) unsigned NOT NULL auto_increment,
* `NO_MODULO` varchar(32) NOT NULL,
* `FK_GRUPO` int(11) NOT NULL,
* `BITS_PERM` varchar(255) NOT NULL default '0',
* PRIMARY KEY (`PK_PERM`),
* UNIQUE KEY `NO_MODULO` (`NO_MODULO`,`FK_GRUPO`)
* ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
* </code>
*
* O array $req->objConfig->permissions ou o campo BITS_PERM armazenam para
* o grupo FK_GRUPO um número decimal inteiro correspondente à soma dos
* inteiros de cada ação a que o grupo tem direito conforme definido em
* $req->objConfig->actions.
* Caso encontre-se um array ou string (que represente um array) ao invés
* de um número decimal inteiro assume-se que existam sub-tipos de ação
* ($_GET['t']), onde então usa-se o valor de índice $_GET['t'] do array.
*
* Assume-se que:
* - PK_GRUPO = 0 ou PK_USUARIO = 0 (zero) é administrador e tem todas
* as permissões.
* - Se o valor da permissão para a ação for 0 (zero) todos têm permissão
* ($module_conf->actions[$_GET['a']][0] = 0)
*
* No diretório do módulo controlador ($req->strPath) deve-se criar o arquivo
* config.php com a definição da classe module_conf e as definições do
* módulo, entre elas o $actions e opcionalmente o $permissions caso seja
* hard-coded:
* <code>
* public $actions = array('lista' => array(1, array('id' => 0, 'value' => 'Listagem dos grupos')),
* 'add' => array(2, array('id' => 0, 'value' => 'Adicionar novo grupo')),
* 'del' => array(4, array('id' => 0, 'value' => 'Remover um grupo')),
* 'delmulti' => array(8, array('id' => 0, 'value' => 'Remover vários grupos em operação única')),
* 'edit' => array(16, array('id' => 0, 'value' => 'Editar um grupo existente')),
* 'save' => array(32, array('id' => 0, 'value' => 'Gravar os dados de um grupo novo ou existente'))
* );
* public $permissions = array(1 => 31, 6 => 17, 7 => 12, 13 => 31, 23 => 31, 29 => 0);
* </code>
* , onde no $permissions, os valores são a soma dos valores de $acoes dos
* $_GET['a'] a que o ator possui permissão e a chave (0, 1, 2, 3, 4, 5)
* corresponde ao $req->objUser->grupos do usuário logado.
* Cada valor pode ser um inteiro, objeto de permissão ou array quando
* assume-se sub-tipos dentro de cada ação, $_GET['t'] corresponde então à
* chave do array onde deve-se buscar o valor.
* @package Soomp
* @link http://us3.php.net/manual/en/language.operators.bitwise.php
*/
class perms extends model{
/**
* @var string $_strTable nome da tabela com os dados
*/
protected $_strTable = 'TB_PERMS';
/**
* @var string $_strFldPk nome do campo com o pk
*/
protected $_strFldPk = 'PK_PERM';
/**
* @var string $strOrdCampo campo padrão de ordenação
*/
public $strOrdCampo = null;
/**
* @var integer $bitsUser valor da permissão do usuário para o módulo/action conforme os grupos
* É calculado efetuando operação bitwise OR (|) nos valores de $permissions correspondentes
* ao grupo do usuário. Convertido em binário, indica os bits a que a somatória dos grupos
* do usuáro dá acesso.
* É ignorado se o usuário é administrdor (pertence ao grupo 0)
* Deve assumir os valores:
* - true para acesso incondicional de acordo com o usuário/grupos
* - false para proibição
* - um número inteiro que será comparado com o $bitAcao para determinar
* o acesso.
*/
protected $bitsUser = false;
/**
* @var string $t define um sub-tipo da ação
*/
protected $t;
/**
* @var array $bitsPerm define as permissões para cada grupo.
* <code>
* $this->bitsPerm = array(12 => 0, 13 => 32, 15 => 5)
* </code>
* Neste exemplo:
* - o grupo PK_GRUPO=12 não possui permissão
* - o grupo PK_GRUPO=13 possui somente o bit 32 (100000)
* - o grupo PK_GRUPO=15 possui os bits 1 e 4 (000101)
*/
protected $bitsPerm = array();
/**
* Construtor
*/
public function __contruct(){
parent::__construct();
}
/**
* Overload de propriedades privadas
* @param string $var nome da propriedade
* @param mixed $value valor da propriedade
*/
private function __set($var, $value){
$this->$var = $value;
}
/**
* Overload de propriedades privadas
* @param string $var nome da propriedade
* @return mixed valor da propriedade
*/
private function __get($var){
return $this->$var;
}
/**
* Busca as permissões de determinado módulo no banco de dados
* @param string $strModule nome do módulo do qual se desejam as permissões
* @return array $arrPerms array com as permissoes do módulo, as chaves
* correspondem ao FK_GRUPO e os valores o número inteiro correspondente
* aos bits de permissão do grupo (array(FK_GRUPO => BITS_PERM, ...))
*/
public function getBitsPerm($strModule){
if($db = &$this->getDb()){
global $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_ASSOC;
$qry = 'SELECT * FROM TB_PERMS WHERE NO_MODULO='.$db->qstr($strModule);
$arrQry = $db->GetAll($qry);
$arrPerms = array();
foreach($arrQry as $bitGroup){
$arrPerms[$bitGroup['FK_GRUPO']] = $bitGroup['BITS_PERM'];
}
return $arrPerms;
}
}
/**
* Calcula os bits de permissão dado um array de bitsAction a que se tem permissão
*/
public function getBitsUser($arrBits){
$bitsUser = 0;
foreach($arrBits as $bit){
$bitsUser = $bitsUser | $bit;
}
return $bitsUser;
}
/**
* Cria o array no formato PK_GRUPO => PERM
* @param array $bitsPerm
* @see perms::setBitsUser
*/
public function setBitsPerm($bitsPerm){
foreach($bitsPerm as $grupo => $perm){
if(is_object($perm)){
$this->bitsPerm[$perm->FK_GRUPO] = $perm->BITS_PERM;
}else{
$this->bitsPerm[$grupo] = $bitsPerm[$grupo];
}
}
}
/**
* Calcula $bitsUser para o módulo solicitado e define $bitsPerm
*
* Resume as permissões de acesso a um determinado módulo de acordo com
* os grupos do usuário.
* @param object $objUser objeto do usuário logado
* @param array $bitsPerm array com as permissões de cada grupo para um determinado módulo.
* Pode ser um array simples no formato grupo => permissao
* <code>
* $bitsPermsModule = array(2 => 34, 4 => 12, ...);
* </code>
* Caso o módulo necessite granulação das permissões para uma mesma ação
* o valor de permissão pode ser um array
* <code>
* $bitsPermsModule = array(2 => array(23, 12, 34), 4 => 12, ...);
* </code>
* Pode ser um array de objetos de perms (perms.classe.php) recuperados
* do banco de dados
* <code>
* $bitsPermsModule = array(0 => $objPerms1,
* 1 => $objPerms2,
* ...);
* </code>
* O $bitsPermsModule também pode ser misto, isto é, valores podem ser o
* número inteiro, array ou o objeto mesclados, desde que não haja
* conflito de chaves.
*/
public function setBitsUser(usuario $objUser, $bitsPerm){
/**
* Garante acesso automático caso:
* - empty(bitsActions) - se existe mas é vazio então ok;
* - $objUser->PK_USUARIO = 0
* - $objUser->grupos possuir grupo com PK_GRUPO = 0;
* a ausência de permissões indica falta de configuração das
* permissões, portanto só admin.
*/
// Usuário admin
if(property_exists($objUser, CFG_USUARIO_DB_PK) && $objUser->{CFG_USUARIO_DB_PK} === 0){
$this->bitsUser = true;
return;
// Ou grupo Admin
}else{
if(empty($objUser->grupos)){
$this->bitsUser = false;
return;
}else{
foreach(@$objUser->grupos as $grupo){
if($grupo->{CFG_GRUPO_DB_PK} == 0){
$this->bitsUser = true;
return;
}
}
}
}
/**
* Não é admin, tem grupos e existem permissões configuradas,
* calcula a permissão.
* Cria o array no formato PK_GRUPO => PERM
*/
$this->setBitsPerm($bitsPerm);
/**
* Calcula os bits do usuário baseado nos grupos
*/
if(!empty($objUser->grupos)){
foreach(@$objUser->grupos as $objGrupo){
$this->setBitsGroup($objGrupo);
}
}else{
$this->bitsUser = false;
}
}
/**
* Define $this->bitsUser para uso com grupos
* @param grupo $objGrupo
* @param array $bitsPerm array com as permissões de cada grupo para um determinado módulo.
*/
public function setBitsGroup($objGrupo, $bitsPerm = false){
if($bitsPerm) $this->setBitsPerm($bitsPerm);
$intPerm = isset($this->bitsPerm[$objGrupo->{CFG_GRUPO_DB_PK}]) ? (int) $this->bitsPerm[$objGrupo->{CFG_GRUPO_DB_PK}] : 0;
if(is_array($intPerm)){
$t = (int) $_GET['t'];
$intPerm = $intPerm[$t];
}
$this->bitsUser = (int) ($this->bitsUser | $intPerm);
}
/**
* Retorna se há permissão para o recurso solicitado
* @param string $strAcao
* @param integer valor de permissão do usuário, se omitido usa
* $this->bitsUser calculado em setBitsUser
* @return boolean true ou false cfme tenha ou nao acesso
*/
public function checkUser($bitAcao, $bitsUser = false){
if($bitsUser){
$this->bitsUser = $bitsUser;
}
if(is_bool($this->bitsUser)){
return $this->bitsUser;
}else{
if($this->checkBit((int) $this->bitsUser, (int) $bitAcao)){
return true;
}
}
return false;
}
/**
* Verifica se um numero inteiro $bitsUser faz parte do valor da permissão
* $intVal através de operação bitwise
* @param integer $bitsUser valor de permissão de um usuário cfme. seus grupos, por ex. 1+2+4+16 = 23
* @param integer $bitAction valor da permissão de uma ação, por ex. 4
*/
public function checkBit($bitsUser, $bitAction){
if((int) $bitsUser & (int) $bitAction){
return true;
}
return false;
}
}
?>

Documentation generated on Sun, 09 Mar 2008 23:52:53 -0300 by phpDocumentor 1.4.0

Source for file perms.classe.php