lib/SAMURAI/Permiso.php

   1 <?php
   2 // vim: set expandtab tabstop=4 softtabstop=4 shiftwidth=4:
   3 // +----------------------------------------------------------------------+
   4 // | PHP Version 4                                                        |
   5 // +----------------------------------------------------------------------+
   6 // | Copyright (c) 1997-2003 The PHP Group                                |
   7 // +----------------------------------------------------------------------+
   8 // | This source file is subject to version 2.02 of the PHP license,      |
   9 // | that is bundled with this package in the file LICENSE, and is        |
  10 // | available at through the world-wide-web at                           |
  11 // | http://www.php.net/license/2_02.txt.                                 |
  12 // | If you did not receive a copy of the PHP license and are unable to   |
  13 // | obtain it through the world-wide-web, please send a note to          |
  14 // | license@php.net so we can mail you a copy immediately.               |
  15 // +----------------------------------------------------------------------+
  16 // | Created: Tue May 27 11:20:04 2003
  17 // | Author:  Martin Marrese - Myrna Degano <mmarre@mecon.gov.ar - mdegan@mecon.gov.ar>
  18 // +----------------------------------------------------------------------+
  19 //
  20 // $Id$
  21 // $Author$
  22 // $URL$
  23 // $Date$
  24 // $Rev$
  25 //
  26
  27 require_once 'PEAR.php';
  28
  29 // +X2C Class 210 :SAMURAI_Permiso
  30 /**
  31  * Clase para el manejo de los Permisos.
  32  *
  33  * @access public
  34  */
  35 class SAMURAI_Permiso {
  36     /**
  37      * Identificador del permiso.
  38      *
  39      * @var    int $id
  40      * @access protected
  41      */
  42     var $_id;
  43
  44     /**
  45      * Descripcion del permiso.
  46      *
  47      * @var    string $descripcion
  48      * @access protected
  49      */
  50     var $_descripcion;
  51
  52     /**
  53      * Objeto Samurai_DB
  54      *
  55      * @var    SAMURAI_DB $db
  56      * @access protected
  57      */
  58     var $_db;
  59
  60     /**
  61      * Indentificador del ultimo que realizo alguna operacion sobre el permiso
  62      *
  63      * @var    string $responsable
  64      * @access protected
  65      */
  66     var $_responsable;
  67
  68     /**
  69      * Gets Id.
  70      *
  71      * @return int
  72      * @access public
  73      */
  74     function getId()
  75     {
  76         return $this->_id;
  77     }
  78     /**
  79      * Sets Id.
  80      *
  81      * @param  int $id Id.
  82      *
  83      * @return void
  84      * @access public
  85      */
  86     function setId($id)
  87     {
  88         $this->_id = $id;
  89     }
  90
  91     /**
  92      * Gets Descripcion.
  93      *
  94      * @return string
  95      * @access public
  96      */
  97     function getDescripcion()
  98     {
  99         return $this->_descripcion;
 100     }
 101     /**
 102      * Sets Descripcion.
 103      *
 104      * @param  string $descripcion Descripcion.
 105      *
 106      * @return void
 107      * @access public
 108      */
 109     function setDescripcion($descripcion)
 110     {
 111         $this->_descripcion = $descripcion;
 112     }
 113
 114     /**
 115      * Gets Responsable.
 116      *
 117      * @return string
 118      * @access public
 119      */
 120     function getResponsable()
 121     {
 122         return $this->_responsable;
 123     }
 124     /**
 125      * Sets Responsable.
 126      *
 127      * @param  string $responsable Responsable.
 128      *
 129      * @return void
 130      * @access public
 131      */
 132     function setResponsable($responsable)
 133     {
 134         $this->_responsable = $responsable;
 135     }
 136
 137     // ~X2C
 138
 139     // +X2C Operation 259
 140     /**
 141      * Constructor. Si recibe como parametro el identificador del permiso, busca la informacion en la DB.
 142      *
 143      * @param  SAMURAI_DB &$db Objeto conexion
 144      * @param  int $id Identificador del permiso
 145      *
 146      * @return void
 147      * @access public
 148      */
 149     function SAMURAI_Permiso(&$db, $id = null) // ~X2C
 150     {
 151         $this->_db          = $db;
 152         $this->_id          = $id;
 153         $this->setDescripcion(null);
 154         if (!is_null($id)) {
 155             $this->_obtenerDatosDb();
 156         }
 157     }
 158     // -X2C
 159
 160     // +X2C Operation 295
 161     /**
 162      * Obtiene de la base de datos la informacion del permiso
 163      *
 164      * @return void
 165      * @access protected
 166      */
 167     function _obtenerDatosDb() // ~X2C
 168     {
 169         $sql = parse_ini_file(dirname(__FILE__) . '/Permiso/consultas.ini', true);
 170         $tmp = $sql['obtener_datos_permiso'].$sql['obtener_datos_permiso2'];
 171         $dbh = $this->_db->prepare($tmp);
 172         $tmp = array ($this->_id);
 173         $res = $this->_db->execute($dbh,$tmp);
 174
 175         if ($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
 176             if (isset($re['desc_permiso'])) {
 177                $this->setDescripcion($re['desc_permiso']);
 178             }
 179             else {
 180                 $this->setDescripcion();
 181             }
 182             if (isset($re['responsable'])) {
 183                 $this->setResponsable($re['responsable']);
 184             }
 185             else {
 186                 $this->setResponsable();
 187             }
 188         }
 189     }
 190     // -X2C
 191
 192
 193     // +X2C Operation 316
 194     /**
 195      * Modifica la base de datos segun accion
 196      *
 197      * @param  string $accion Indica la accion a realizar
 198      *
 199      * @return mixed
 200      * @access public
 201      */
 202     function guardarDatos($accion = grabar) // ~X2C
 203     {
 204         $accion = strtolower($accion);
 205         switch ($accion)  {
 206             case 'grabar':
 207                 $res = $this->_grabarDb();
 208                 break;
 209             case 'modificar':
 210                 $res = $this->_modificarDb();
 211                 break;
 212             case 'eliminar':
 213                 $res = $this->_borrarDb();
 214                 break;
 215         }
 216         return $res;
 217     }
 218     // -X2C
 219
 220     // +X2C Operation 317
 221     /**
 222      * Graba en base el permiso
 223      *
 224      * @return mixed
 225      * @access protected
 226      */
 227     function _grabarDb() // ~X2C
 228     {
 229         $idPermiso = $this->_db->nextId('permiso');
 230         $datos = array (
 231                     'id_permiso'   => $idPermiso,
 232                     'desc_permiso' => $this->getDescripcion(),
 233                     'responsable'  => $this->getResponsable(),
 234                 );
 235         return $this->_db->autoExecute('samurai.permiso', $datos, DB_AUTOQUERY_INSERT);
 236     }
 237     // -X2C
 238
 239     // +X2C Operation 318
 240     /**
 241      * Borra de la base el permiso
 242      *
 243      * @return mixed
 244      * @access protected
 245      */
 246     function _borrarDb() // ~X2C
 247     {
 248         $sql = parse_ini_file(dirname(__FILE__) . '/Permiso/consultas.ini', true);
 249         $datos[] = $this->getId();
 250         //Verifico que el permiso no tenga asociaciones
 251         $tmp = $sql['verificar_asociaciones1'].$sql['obtener_datos_permiso2'];
 252         $dbh = $this->_db->prepare($tmp);
 253         $res = $this->_db->execute($dbh, $datos);
 254         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 255             return new PEAR_Error("Hay sistemas asociados al permiso seleccionado");
 256         }
 257         $tmp = $sql['verificar_asociaciones2'].$sql['obtener_datos_permiso2'];
 258         $dbh = $this->_db->prepare($tmp);
 259         $res = $this->_db->execute($dbh, $datos);
 260         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 261             return new PEAR_Error("Hay pefiles asociados al permiso seleccionado");
 262         }
 263         //
 264         //Borro el permiso de la base
 265         $tmp = $sql['borrar_permiso'];
 266         $dbh = $this->_db->prepare($tmp);
 267         return $this->_db->execute($dbh, $datos);
 268         //
 269     }
 270     // -X2C
 271
 272     // +X2C Operation 319
 273     /**
 274      * Actualiza los datos del permiso
 275      *
 276      * @return mixed
 277      * @access protected
 278      */
 279     function _modificarDb() // ~X2C
 280     {
 281         $datos = array (
 282                     'id_permiso'   => $this->getId(),
 283                     'desc_permiso' => $this->getDescripcion(),
 284                     'responsable'  => $this->getResponsable(),
 285                 );
 286         return $this->_db->autoExecute('samurai.permiso', $datos, DB_AUTOQUERY_UPDATE, 'id_permiso ='.$this->getId());
 287     }
 288     // -X2C
 289
 290
 291     // +X2C Operation 332
 292     /**
 293      * Devuleve un array con los identificadores de todos los permisos.
 294      *
 295      * @param  SAMURAI_DB &$db Base de Datos
 296      * @param  int $id_sistema Identificador del sistema
 297      *
 298      * @return array(int)
 299      * @access protected
 300      * @static
 301      */
 302     function _getIdPermisos(&$db, $id_sistema = null) // ~X2C
 303     {
 304         //OBTENGO LOS ID DE LA BASE
 305         $rta = array();
 306         $tmp = array();
 307         $sql = parse_ini_file(dirname(__FILE__) . '/Permiso/consultas.ini', true);
 308         $consulta = $sql['obtener_datos_permiso'];
 309         if ($id_sistema) {
 310             $consulta.= $sql['obtener_datos_permiso3'];
 311             $tmp[] = $id_sistema;
 312         }
 313         $consulta.= $sql['obtener_datos_permiso5'];
 314         $dbh = $db->prepare($consulta);
 315         $res = $db->execute($dbh, $tmp);
 316         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 317             array_push($rta,$re['id_permiso']);
 318         }
 319         $res->free();
 320         return $rta;
 321     }
 322     // -X2C
 323
 324     // +X2C Operation 333
 325     /**
 326      * Devuelve un array asociativo en donde la clave es el identificador y el valor es la descripcion del permiso
 327      *
 328      * @param  SAMURAI_DB &$db Base de Datos
 329      * @param  int $id_sistema Identificador del sistema
 330      *
 331      * @return array()
 332      * @access public
 333      * @static
 334      */
 335     function getArrayPermisos(&$db, $id_sistema = null) // ~X2C
 336     {
 337         //FORECHEO LO QUE ME DEVUELVA GET PERMISOS
 338         $rta = array ();
 339         foreach (SAMURAI_Permiso::getPermisos($db, $id_sistema) as $permiso) {
 340             $rta[$permiso->getId()] = $permiso->getDescripcion();
 341         }
 342         return $rta;
 343     }
 344     // -X2C
 345
 346     // +X2C Operation 334
 347     /**
 348      * Devuelve el array de permisos
 349      *
 350      * @param  SAMURAI_DB &$db Base de Datos
 351      * @param  int $id_sistema Identificador del sistema
 352      *
 353      * @return array(Permiso)
 354      * @access public
 355      * @static
 356      */
 357     function getPermisos(&$db, $id_sistema = null) // ~X2C
 358     {
 359         $rta = array ();
 360         foreach (SAMURAI_Permiso::_getIdPermisos($db, $id_sistema) as $id) {
 361             $tmp = new SAMURAI_Permiso($db,$id);
 362             array_push($rta, $tmp);
 363         }
 364         return $rta;
 365     }
 366     // -X2C
 367
 368     // +X2C Operation 364
 369     /**
 370      * Devuelve true si esta asociado a algun sistema, caso contrario devuelve false
 371      *
 372      * @return bool
 373      * @access public
 374      */
 375     function asociadoASistema() // ~X2C
 376     {
 377         $rta = array();
 378         $tmp = array();
 379         $sql = parse_ini_file(dirname(__FILE__) . '/Permiso/consultas.ini', true);
 380         $tmp = $sql['verificar_asociaciones1'].$sql['obtener_datos_permiso2'];
 381         $dbh = $this->_db->prepare($tmp);
 382         $res = $this->_db->execute($dbh, array ($this->getId()));
 383         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 384             return true;
 385         }
 386         else {
 387             return false;
 388         }
 389     }
 390     // -X2C
 391
 392     /**
 393      * Metodo que devuelve los datos necesarios para listar permisos.
 394      *
 395      * @param SAMURAI_DB &$db Base de Datos
 396      * @param int $id_sistema Identificador de un sistema en particular.
 397      *
 398      * @return mixed
 399      * @access public
 400      * @static
 401      */
 402     function getPermisosPager(&$db, $id_sistema = null) {
 403
 404         //@TODO REEMPLAZA A getPermisos
 405
 406         if ($id_sistema) {
 407             $sql = '
 408                 SELECT p.id_permiso, p.desc_permiso, p.responsable
 409                 FROM samurai.permiso AS p, samurai.perm_sist AS ps
 410                 WHERE ps.id_sistema = '. $id_sistema .'
 411                 AND ps.id_permiso = p.id_permiso
 412                 ORDER BY p.desc_permiso
 413                 ';
 414         }
 415         else {
 416             $sql = '
 417                 SELECT p.id_permiso, p.desc_permiso, count(ps.id_sistema) AS cuenta
 418                 FROM samurai.permiso AS p
 419                     LEFT JOIN samurai.perm_sist AS ps
 420                         ON (p.id_permiso = ps.id_permiso)
 421                 GROUP BY p.id_permiso, p.desc_permiso
 422                 ORDER BY p.desc_permiso
 423                 ';
 424         }
 425         return $db->query ($sql);
 426     }
 427
 428 } // -X2C Class :SAMURAI_Permiso
 429
 430 ?>