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
 194     // +X2C Operation 316
 195     /**
 196      * Modifica la base de datos segun accion
 197      *
 198      * @param  string $accion Indica la accion a realizar
 199      *
 200      * @return mixed
 201      * @access public
 202      */
 203     function guardarDatos($accion = grabar) // ~X2C
 204     {
 205         $accion = strtolower($accion);
 206         switch ($accion)  {
 207             case 'grabar':
 208                 $res = $this->_grabarDb();
 209                 break;
 210             case 'modificar':
 211                 $res = $this->_modificarDb();
 212                 break;
 213             case 'eliminar':
 214                 $res = $this->_borrarDb();
 215                 break;
 216         }
 217         return $res;
 218     }
 219     // -X2C
 220
 221     // +X2C Operation 317
 222     /**
 223      * Graba en base el permiso
 224      *
 225      * @return mixed
 226      * @access protected
 227      */
 228     function _grabarDb() // ~X2C
 229     {
 230         $idPermiso = $this->_db->nextId('permiso');
 231         $datos = array (
 232                     'id_permiso'   => $idPermiso,
 233                     'desc_permiso' => $this->getDescripcion(),
 234                     'responsable'  => $this->getResponsable(),
 235                 );
 236         return $this->_db->autoExecute('permiso', $datos, DB_AUTOQUERY_INSERT);
 237     }
 238     // -X2C
 239
 240     // +X2C Operation 318
 241     /**
 242      * Borra de la base el permiso
 243      *
 244      * @return mixed
 245      * @access protected
 246      */
 247     function _borrarDb() // ~X2C
 248     {
 249         $sql = parse_ini_file(dirname(__FILE__) . '/Permiso/consultas.ini', true);
 250         $datos[] = $this->getId();
 251         //Verifico que el permiso no tenga asociaciones
 252         $tmp = $sql['verificar_asociaciones1'].$sql['obtener_datos_permiso2'];
 253         $dbh = $this->_db->prepare($tmp);
 254         $res = $this->_db->execute($dbh, $datos);
 255         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 256             return new PEAR_Error("Hay sistemas asociados al permiso seleccionado");
 257         }
 258         $tmp = $sql['verificar_asociaciones2'].$sql['obtener_datos_permiso2'];
 259         $dbh = $this->_db->prepare($tmp);
 260         $res = $this->_db->execute($dbh, $datos);
 261         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 262             return new PEAR_Error("Hay pefiles asociados al permiso seleccionado");
 263         }
 264         //
 265         //Borro el permiso de la base
 266         $tmp = $sql['borrar_permiso'].$sql['obtener_datos_permiso2'];
 267         $dbh = $this->_db->prepare($tmp);
 268         return $this->_db->execute($dbh, $datos);
 269         //
 270     }
 271     // -X2C
 272
 273     // +X2C Operation 319
 274     /**
 275      * Actualiza los datos del permiso
 276      *
 277      * @return mixed
 278      * @access protected
 279      */
 280     function _modificarDb() // ~X2C
 281     {
 282         $datos = array (
 283                     'id_permiso'   => $this->getId(),
 284                     'desc_permiso' => $this->getDescripcion(),
 285                     'responsable'  => $this->getResponsable(),
 286                 );
 287         return $this->_db->autoExecute('permiso', $datos, DB_AUTOQUERY_UPDATE, 'id_permiso ='.$this->getId());
 288     }
 289     // -X2C
 290
 291
 292     // +X2C Operation 332
 293     /**
 294      * Devuleve un array con los identificadores de todos los permisos.
 295      *
 296      * @param  SAMURAI_DB &$db Base de Datos
 297      *
 298      * @return array(int)
 299      * @access protected
 300      * @static
 301      */
 302     function _getIdPermisos(&$db) // ~X2C
 303     {
 304         //OBTENGO LOS ID DE LA BASE
 305         $rta = array();
 306         $sql = parse_ini_file(dirname(__FILE__) . '/Permiso/consultas.ini', true);
 307         $dbh = $db->prepare($sql['obtener_datos_permiso']);
 308         $tmp[] = $_SESSION['samurai']['id_sistema'];
 309         $res = $db->execute($dbh, $tmp);
 310         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 311             array_push($rta,$re['id_permiso']);
 312         }
 313         $res->free();
 314         return $rta;
 315     }
 316     // -X2C
 317
 318     // +X2C Operation 333
 319     /**
 320      * Devuelve un array asociativo en donde la clave es el identificador y el valor es la descripcion del permiso
 321      *
 322      * @param  SAMURAI_DB &$db Base de Datos
 323      *
 324      * @return array()
 325      * @access public
 326      * @static
 327      */
 328     function getArrayPermisos(&$db) // ~X2C
 329     {
 330         //FORECHEO LO QUE ME DEVUELVA GET PERMISOS
 331         $rta = array ();
 332         foreach (SAMURAI_Permiso::getPermisos($db) as $permiso) {
 333             $rta[$permiso->getId()] = $permiso->getDescripcion();
 334         }
 335         return $rta;
 336     }
 337     // -X2C
 338
 339     // +X2C Operation 334
 340     /**
 341      * Devuelve el array de permisos
 342      *
 343      * @param  SAMURAI_DB &$db Base de Datos
 344      *
 345      * @return array(Permiso)
 346      * @access public
 347      * @static
 348      */
 349     function getPermisos(&$db) // ~X2C
 350     {
 351         $rta = array ();
 352         foreach (SAMURAI_Permiso::_getIdPermisos($db) as $id) {
 353             $tmp = new SAMURAI_Permiso($db,$id);
 354             array_push($rta, $tmp);
 355         }
 356         return $rta;
 357     }
 358     // -X2C
 359
 360 } // -X2C Class :SAMURAI_Permiso
 361
 362 ?>