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('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('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         $dbh = $db->prepare($consulta);
 314         $res = $db->execute($dbh, $tmp);
 315         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 316             array_push($rta,$re['id_permiso']);
 317         }
 318         $res->free();
 319         return $rta;
 320     }
 321     // -X2C
 322
 323     // +X2C Operation 333
 324     /**
 325      * Devuelve un array asociativo en donde la clave es el identificador y el valor es la descripcion del permiso
 326      *
 327      * @param  SAMURAI_DB &$db Base de Datos
 328      * @param  int $id_sistema Identificador del sistema
 329      *
 330      * @return array()
 331      * @access public
 332      * @static
 333      */
 334     function getArrayPermisos(&$db, $id_sistema = null) // ~X2C
 335     {
 336         //FORECHEO LO QUE ME DEVUELVA GET PERMISOS
 337         $rta = array ();
 338         foreach (SAMURAI_Permiso::getPermisos($db, $id_sistema) as $permiso) {
 339             $rta[$permiso->getId()] = $permiso->getDescripcion();
 340         }
 341         return $rta;
 342     }
 343     // -X2C
 344
 345     // +X2C Operation 334
 346     /**
 347      * Devuelve el array de permisos
 348      *
 349      * @param  SAMURAI_DB &$db Base de Datos
 350      * @param  int $id_sistema Identificador del sistema
 351      *
 352      * @return array(Permiso)
 353      * @access public
 354      * @static
 355      */
 356     function getPermisos(&$db, $id_sistema = null) // ~X2C
 357     {
 358         $rta = array ();
 359         foreach (SAMURAI_Permiso::_getIdPermisos($db, $id_sistema) as $id) {
 360             $tmp = new SAMURAI_Permiso($db,$id);
 361             array_push($rta, $tmp);
 362         }
 363         return $rta;
 364     }
 365     // -X2C
 366
 367     // +X2C Operation 364
 368     /**
 369      * Devuelve true si esta asociado a algun sistema, caso contrario devuelve false
 370      *
 371      * @return bool
 372      * @access public
 373      */
 374     function asociadoASistema() // ~X2C
 375     {
 376         $rta = array();
 377         $tmp = array();
 378         $sql = parse_ini_file(dirname(__FILE__) . '/Permiso/consultas.ini', true);
 379         $tmp = $sql['verificar_asociaciones1'].$sql['obtener_datos_permiso2'];
 380         $dbh = $this->_db->prepare($tmp);
 381         $res = $this->_db->execute($dbh, array ($this->getId()));
 382         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 383             return true;
 384         }
 385         else {
 386             return false;
 387         }
 388     }
 389     // -X2C
 390
 391 } // -X2C Class :SAMURAI_Permiso
 392
 393 ?>