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         $res =  $this->_db->autoExecute('samurai.permiso', $datos, DB_AUTOQUERY_INSERT);
 236         if (PEAR::isError($res)) {
 237             return $res;
 238         }
 239         $this->setId($idPermiso);
 240     }
 241     // -X2C
 242
 243     // +X2C Operation 318
 244     /**
 245      * Borra de la base el permiso
 246      *
 247      * @return mixed
 248      * @access protected
 249      */
 250     function _borrarDb() // ~X2C
 251     {
 252         $sql = parse_ini_file(dirname(__FILE__) . '/Permiso/consultas.ini', true);
 253         $datos[] = $this->getId();
 254         //Verifico que el permiso no tenga asociaciones
 255         $tmp = $sql['verificar_asociaciones1'].$sql['obtener_datos_permiso2'];
 256         $dbh = $this->_db->prepare($tmp);
 257         $res = $this->_db->execute($dbh, $datos);
 258         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 259             return new PEAR_Error("Hay sistemas asociados al permiso seleccionado");
 260         }
 261         $tmp = $sql['verificar_asociaciones2'].$sql['obtener_datos_permiso2'];
 262         $dbh = $this->_db->prepare($tmp);
 263         $res = $this->_db->execute($dbh, $datos);
 264         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 265             return new PEAR_Error("Hay pefiles asociados al permiso seleccionado");
 266         }
 267         //
 268         //Borro el permiso de la base
 269         $tmp = $sql['borrar_permiso'];
 270         $dbh = $this->_db->prepare($tmp);
 271         return $this->_db->execute($dbh, $datos);
 272         //
 273     }
 274     // -X2C
 275
 276     // +X2C Operation 319
 277     /**
 278      * Actualiza los datos del permiso
 279      *
 280      * @return mixed
 281      * @access protected
 282      */
 283     function _modificarDb() // ~X2C
 284     {
 285         $datos = array (
 286                     'id_permiso'   => $this->getId(),
 287                     'desc_permiso' => $this->getDescripcion(),
 288                     'responsable'  => $this->getResponsable(),
 289                 );
 290         return $this->_db->autoExecute('samurai.permiso', $datos, DB_AUTOQUERY_UPDATE, 'id_permiso ='.$this->getId());
 291     }
 292     // -X2C
 293
 294
 295     // +X2C Operation 332
 296     /**
 297      * Devuleve un array con los identificadores de todos los permisos.
 298      *
 299      * @param  SAMURAI_DB &$db Base de Datos
 300      * @param  int $id_sistema Identificador del sistema
 301      *
 302      * @return array(int)
 303      * @access protected
 304      * @static
 305      */
 306     function _getIdPermisos(&$db, $id_sistema = null) // ~X2C
 307     {
 308         //OBTENGO LOS ID DE LA BASE
 309         $rta = array();
 310         $tmp = array();
 311         $sql = parse_ini_file(dirname(__FILE__) . '/Permiso/consultas.ini', true);
 312         $consulta = $sql['obtener_datos_permiso'];
 313         if ($id_sistema) {
 314             $consulta.= $sql['obtener_datos_permiso3'];
 315             $tmp[] = $id_sistema;
 316         }
 317         $consulta.= $sql['obtener_datos_permiso5'];
 318         $dbh = $db->prepare($consulta);
 319         $res = $db->execute($dbh, $tmp);
 320         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 321             array_push($rta,$re['id_permiso']);
 322         }
 323         $res->free();
 324         return $rta;
 325     }
 326     // -X2C
 327
 328     // +X2C Operation 333
 329     /**
 330      * Devuelve un array asociativo en donde la clave es el identificador y el valor es la descripcion del permiso
 331      *
 332      * @param  SAMURAI_DB &$db Base de Datos
 333      * @param  int $id_sistema Identificador del sistema
 334      *
 335      * @return array()
 336      * @access public
 337      * @static
 338      */
 339     function getArrayPermisos(&$db, $id_sistema = null) // ~X2C
 340     {
 341         //FORECHEO LO QUE ME DEVUELVA GET PERMISOS
 342         $rta = array ();
 343         foreach (SAMURAI_Permiso::getPermisos($db, $id_sistema) as $permiso) {
 344             $rta[$permiso->getId()] = $permiso->getDescripcion();
 345         }
 346         return $rta;
 347     }
 348     // -X2C
 349
 350     // +X2C Operation 334
 351     /**
 352      * Devuelve el array de permisos
 353      *
 354      * @param  SAMURAI_DB &$db Base de Datos
 355      * @param  int $id_sistema Identificador del sistema
 356      *
 357      * @return array(Permiso)
 358      * @access public
 359      * @static
 360      */
 361     function getPermisos(&$db, $id_sistema = null) // ~X2C
 362     {
 363         $rta = array ();
 364         foreach (SAMURAI_Permiso::_getIdPermisos($db, $id_sistema) as $id) {
 365             $tmp = new SAMURAI_Permiso($db,$id);
 366             array_push($rta, $tmp);
 367         }
 368         return $rta;
 369     }
 370     // -X2C
 371
 372     // +X2C Operation 364
 373     /**
 374      * Devuelve true si esta asociado a algun sistema, caso contrario devuelve false
 375      *
 376      * @return bool
 377      * @access public
 378      */
 379     function asociadoASistema() // ~X2C
 380     {
 381         $rta = array();
 382         $tmp = array();
 383         $sql = parse_ini_file(dirname(__FILE__) . '/Permiso/consultas.ini', true);
 384         $tmp = $sql['verificar_asociaciones1'].$sql['obtener_datos_permiso2'];
 385         $dbh = $this->_db->prepare($tmp);
 386         $res = $this->_db->execute($dbh, array ($this->getId()));
 387         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 388             return true;
 389         }
 390         else {
 391             return false;
 392         }
 393     }
 394     // -X2C
 395
 396     /**
 397      * Metodo que devuelve los datos necesarios para listar permisos.
 398      *
 399      * @param SAMURAI_DB &$db Base de Datos
 400      * @param int $id_sistema Identificador de un sistema en particular.
 401      *
 402      * @return mixed
 403      * @access public
 404      * @static
 405      */
 406     function getPermisosPager(&$db, $id_sistema = null) {
 407
 408         //@TODO REEMPLAZA A getPermisos
 409
 410         if ($id_sistema) {
 411             $sql = '
 412                 SELECT p.id_permiso, p.desc_permiso, p.responsable
 413                 FROM samurai.permiso AS p, samurai.perm_sist AS ps
 414                 WHERE ps.id_sistema = '. $id_sistema .'
 415                 AND ps.id_permiso = p.id_permiso
 416                 ORDER BY p.desc_permiso
 417                 ';
 418         }
 419         else {
 420             $sql = '
 421                 SELECT p.id_permiso, p.desc_permiso, NOT count(ps.id_sistema) AS cuenta
 422                 FROM samurai.permiso AS p
 423                     LEFT JOIN samurai.perm_sist AS ps
 424                         ON (p.id_permiso = ps.id_permiso)
 425                 GROUP BY p.id_permiso, p.desc_permiso
 426                 ORDER BY p.desc_permiso
 427                 ';
 428         }
 429         return $db->query ($sql);
 430     }
 431 } // -X2C Class :SAMURAI_Permiso
 432
 433 ?>