lib/SAMURAI/Perfil.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 208 :SAMURAI_Perfil
  30 /**
  31  * Clase para el manejo de los perfies.
  32 @see \ref page_samurai_html_perfil
  33  *
  34  * @access public
  35  */
  36 class SAMURAI_Perfil {
  37     /**
  38      * Identificador del perfil.
  39      *
  40      * @var    int $id
  41      * @access protected
  42      */
  43     var $_id;
  44
  45     /**
  46      * Descripcion del perfil.
  47      *
  48      * @var    string $descripcion
  49      * @access protected
  50      */
  51     var $_descripcion;
  52
  53     /**
  54      * @var    SAMURAI_DB $db
  55      * @access protected
  56      */
  57     var $_db;
  58
  59     /**
  60      * Responsable de las ultimas modificaciones
  61      *
  62      * @var    string $responsable
  63      * @access protected
  64      */
  65     var $_responsable;
  66
  67     /**
  68      * Array con los permisos asignados al perfil. Solo se cargan cuando se esta trabajando con el abm puesto que varian segun cada sistema.
  69      *
  70      * @var    array(int) $permisos
  71      * @access private
  72      */
  73     var $_permisos;
  74
  75     /**
  76      * Identificador del sistema en el cual se esta trabajando
  77      *
  78      * @var    int $idSistema
  79      * @access protected
  80      */
  81     var $_idSistema;
  82
  83     /**
  84      * Gets Id.
  85      *
  86      * @return int
  87      * @access public
  88      */
  89     function getId()
  90     {
  91         return $this->_id;
  92     }
  93     /**
  94      * Sets Id.
  95      *
  96      * @param  int $id Id.
  97      *
  98      * @return void
  99      * @access public
 100      */
 101     function setId($id)
 102     {
 103         $this->_id = $id;
 104     }
 105
 106     /**
 107      * Gets Descripcion.
 108      *
 109      * @return string
 110      * @access public
 111      */
 112     function getDescripcion()
 113     {
 114         return $this->_descripcion;
 115     }
 116     /**
 117      * Sets Descripcion.
 118      *
 119      * @param  string $descripcion Descripcion.
 120      *
 121      * @return void
 122      * @access public
 123      */
 124     function setDescripcion($descripcion)
 125     {
 126         $this->_descripcion = $descripcion;
 127     }
 128
 129     /**
 130      * Gets Responsable.
 131      *
 132      * @return string
 133      * @access public
 134      */
 135     function getResponsable()
 136     {
 137         return $this->_responsable;
 138     }
 139     /**
 140      * Sets Responsable.
 141      *
 142      * @param  string $responsable Responsable.
 143      *
 144      * @return void
 145      * @access public
 146      */
 147     function setResponsable($responsable)
 148     {
 149         $this->_responsable = $responsable;
 150     }
 151
 152     /**
 153      * Gets Permisos.
 154      *
 155      * @return array(int)
 156      * @access public
 157      */
 158     function getPermisos()
 159     {
 160         return $this->_permisos;
 161     }
 162     /**
 163      * Sets Permisos.
 164      *
 165      * @param  array(int) $permisos Permisos.
 166      *
 167      * @return void
 168      * @access public
 169      */
 170     function setPermisos($permisos)
 171     {
 172         $this->_permisos = $permisos;
 173     }
 174
 175     // ~X2C
 176
 177     // +X2C Operation 229
 178     /**
 179      * Constructor. Si recibe un identificador como parametro, busca la informacion en la base.
 180      *
 181      * @param  SAMURAI_DB &$db Objeto conexion
 182      * @param  int $id Identificador del perfil.
 183      * @param  int $idSistema Identificador del sistema en el que se esta trabajando
 184      *
 185      * @return void
 186      * @access public
 187      */
 188     function SAMURAI_Perfil(&$db, $id = null, $idSistema = null) // ~X2C
 189     {
 190         $this->_db = $db;
 191         $this->_idSistema = $idSistema;
 192         if (!is_null($id)) {
 193             $this->setId($id);
 194             $this->_obtenerDatosDb();
 195         }
 196         else {
 197             //INICIALIZO LA VI
 198             $this->_id          = null;
 199             $this->_descripcion = null;
 200             $this->_permisos    = null;
 201         }
 202     }
 203     // -X2C
 204
 205     // +X2C Operation 322
 206     /**
 207      * Obtiene los datos de la base de datos
 208      *
 209      * @return void
 210      * @access protected
 211      */
 212     function _obtenerDatosDb() // ~X2C
 213     {
 214         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 215         $tmp = $sql['obtener_datos_perfil'].$sql['obtener_datos_perfil2'];
 216         $dbh = $this->_db->prepare($tmp);
 217         $tmp = array ($this->getId());
 218         $res = $this->_db->execute($dbh,$tmp);
 219         if ($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
 220             if (isset($re['desc_perfil'])) {
 221                $this->setDescripcion($re['desc_perfil']);
 222             }
 223             else {
 224                 $this->setDescripcion();
 225             }
 226             if (isset($re['responsable'])) {
 227                 $this->setResponsable($re['responsable']);
 228             }
 229             else {
 230                 $this->setResponsable();
 231             }
 232         }
 233
 234         //OBTENGO LOS PERMISOS QUE TIENE ASIGNADO EL PERFIL DESDE PERM_PERFIL_SIST
 235         $tmp = $sql['obtener_permisos'];
 236         $dbh = $this->_db->prepare($tmp);
 237         $tmp = array ($this->getId(), $this->_idSistema);
 238         $res = $this->_db->execute($dbh,$tmp);
 239         $rta = array ();
 240         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 241             array_push($rta,$re['id_permiso'].'##'.$re['observaciones']);
 242         }
 243         $this->setPermisos($rta);
 244     }
 245     // -X2C
 246
 247     // +X2C Operation 323
 248     /**
 249      * Redirecciona segun la accion correspondiente
 250      *
 251      * @param  string $accion Representa la accion a desarrollar
 252      *
 253      * @return mixed
 254      * @access public
 255      */
 256     function guardarDatos($accion = grabar) // ~X2C
 257     {
 258         $accion = strtolower($accion);
 259         switch ($accion)  {
 260             case 'grabar':
 261                 $res = $this->_grabarDb();
 262                 break;
 263             case 'modificar':
 264                 $res = $this->_modificarDb();
 265                 break;
 266             case 'eliminar':
 267                 $res = $this->_borrarDb();
 268                 break;
 269         }
 270         return $res;
 271     }
 272     // -X2C
 273
 274     // +X2C Operation 324
 275     /**
 276      * Graba la informacion del perfil en base
 277      *
 278      * @return mixed
 279      * @access protected
 280      */
 281     function _grabarDb() // ~X2C
 282     {
 283         //Obtengo el id del perfil de ser necesario
 284         $nuevo = 0;
 285         if (!$this->getId()) {
 286             //No existe el perfil. Lo cargo por primera vez.
 287             $idPerfil = $this->_db->nextId('perfil');
 288             $this->setId($idPerfil);
 289             $nuevo = 1;
 290         }
 291
 292         //GRABO EN PERM_PERFIL_SIST
 293         $res = $this->_guardarPermisos();
 294         if (PEAR::isError($res)) {
 295             return $res;
 296         }
 297
 298         //GRABO EN PERFIL
 299         if ($nuevo) {
 300             $datos = array (
 301                         'id_perfil'   => $idPerfil,
 302                         'desc_perfil' => $this->getDescripcion(),
 303                         'responsable' => $this->getResponsable(),
 304                     );
 305             $res = $this->_db->autoExecute('samurai.perfil', $datos, DB_AUTOQUERY_INSERT);
 306             if (PEAR::isError($res)) {
 307                 return $res;
 308             }
 309         }
 310         //GRABO EN PERFIL_SIST
 311         $datos = array ('id_perfil'   => $this->getId(),
 312                         'id_sistema'  => $this->_idSistema,
 313                         'responsable' => $this->getResponsable(),
 314                     );
 315         $res = $this->_db->autoExecute('samurai.perfil_sist', $datos, DB_AUTOQUERY_INSERT);
 316     }
 317     // -X2C
 318
 319     // +X2C Operation 325
 320     /**
 321      * Borra la informacion del perfil de la base
 322      *
 323      * @return mixed
 324      * @access protected
 325      */
 326     function _borrarDb() // ~X2C
 327     {
 328         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 329         //Verifico en perfil_sist_usuario
 330         $tmp = $sql['verif_perfil_sist_usuario'];
 331         $dbh = $this->_db->prepare($tmp);
 332         $datos = array ($this->getId(), $this->_idSistema);
 333         $res = $this->_db->execute($dbh, $datos);
 334         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 335             return new PEAR_Error("Hay usuarios asociados al perfil seleccionado");
 336         }
 337         //Borro perm_perfil_sist
 338         $res = $this->_borrarPermisos();
 339         if (PEAR::isError($res)) {
 340             return $res;
 341         }
 342         //Borro perfil_sist
 343         $tmp = $sql['borrar_perfil_sist'];
 344         $dbh = $this->_db->prepare($tmp);
 345         $datos = array ($this->getId(), $this->_idSistema);
 346         $res = $this->_db->execute($dbh, $datos);
 347         if (PEAR::isError($res)) {
 348             return $res;
 349         }
 350         //Verifico en perfil_sist (Perfil asociado a otros sistemas)
 351         $tmp = $sql['verif_perfil_sist'];
 352         $dbh = $this->_db->prepare($tmp);
 353         $datos = array ($this->getId());
 354         $res = $this->_db->execute($dbh, $datos);
 355         if (PEAR::isError($res)) {
 356             return $res;
 357         }
 358         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && $re['cuenta'] == 0) {
 359             //Borro perfil
 360             $tmp = $sql['borrar_perfil'];
 361             $dbh = $this->_db->prepare($tmp);
 362             $datos = array ($this->getId());
 363             $res = $this->_db->execute($dbh, $datos);
 364             if (PEAR::isError($res)) {
 365                 return $res;
 366             }
 367         }
 368     }
 369     // -X2C
 370
 371     // +X2C Operation 326
 372     /**
 373      * @return mixed
 374      * @access protected
 375      */
 376     function _modificarDb() // ~X2C
 377     {
 378         //Modifico la tabla perfil_sist
 379         $datos = array (
 380                     'responsable' => $this->getResponsable(),
 381         );
 382         $res = $this->_db->autoExecute('samurai.perfil_sist', $datos,
 383                 DB_AUTOQUERY_UPDATE, 'id_perfil ='.$this->getId().' AND
 384                 id_sistema='.$this->_idSistema);
 385         if (PEAR::isError($res)) {
 386             return $res;
 387         }
 388
 389         //VERIFICO QUE NO HAYA UN PERFIL CON LOS MISMOS PERMISOS YA ASIGNADO AL SISTEMA
 390         $res = $this->_verifPermisos();
 391         if (PEAR::isError($res)) {
 392             return $res;
 393         }
 394         //Modifico la tabla perm_perfil_sist
 395         $res = $this->_borrarPermisos();
 396         if (PEAR::isError($res)) {
 397             return $res;
 398         }
 399         return $this->_guardarPermisos();
 400     }
 401     // -X2C
 402
 403     // +X2C Operation 338
 404     /**
 405      * Devuleve un array con los identificadores de todos los perfiles.
 406      *
 407      * @param  SAMURAI_DB &$db Base de Datos
 408      * @param  string $filtro Fltro por descripcion del perfil
 409      * @param  int $id_sistema Identificador del sistema
 410      *
 411      * @return array(int)
 412      * @access protected
 413      * @static
 414      */
 415     function _getIdPerfiles(&$db, $filtro = null, $id_sistema = null) // ~X2C
 416     {
 417         //OBTENGO LOS ID DE LA BASE
 418         $rta = array();
 419         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 420         $consulta = $sql['obtener_id_perfiles'];
 421         if ($id_sistema) {
 422             $consulta.= $sql['obtener_id_perfiles3'];
 423         }
 424         if ($filtro) { //Verifico si se paso un filtro
 425             $tmp2 = $consulta.$sql['obtener_id_perfiles2'];
 426             //Reemplazo el filtro por ##?##
 427             $consulta = ereg_replace ('##FILTRO##', $filtro, $tmp2);
 428         }
 429         $consulta.= $sql['obtener_id_perfiles4'];
 430         $dbh = $db->prepare($consulta);
 431         if ($id_sistema) {
 432             $tmp[] = $id_sistema;
 433             $res = $db->execute($dbh, $tmp);
 434         }
 435         else {
 436             $res = $db->execute($dbh);
 437         }
 438         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 439             array_push($rta,$re['id_perfil']);
 440         }
 441         $res->free();
 442         return $rta;
 443     }
 444     // -X2C
 445
 446     // +X2C Operation 339
 447     /**
 448      * Devuelve un array de perfiles
 449      *
 450      * @param  SAMURAI_DB &$db Base de datos
 451      * @param  string $filtro Filtro por nombre del perfil
 452      * @param  int $id_sistema Identificador del sistema
 453      *
 454      * @return array(Perfil)
 455      * @access public
 456      * @static
 457      */
 458     function getPerfiles(&$db, $filtro = null, $id_sistema = null) // ~X2C
 459     {
 460         $rta = array ();
 461         foreach (SAMURAI_Perfil::_getIdPerfiles($db, $filtro, $id_sistema) as $id) {
 462             $tmp = new SAMURAI_Perfil($db,$id, $id_sistema);
 463             array_push($rta, $tmp);
 464         }
 465         return $rta;
 466     }
 467     // -X2C
 468
 469     // +X2C Operation 356
 470     /**
 471      * Devuelve la informacion de los perfiles en un array.
 472      *
 473      * @param  SAMURAI_DB $db Base de Datos
 474      * @param  string $filtro Filtro por descripcion del perfil
 475      * @param  int $id_sistema Identificador del sistema con el que se esta trabajando
 476      *
 477      * @return array()
 478      * @access public
 479      * @static
 480      */
 481     function getArrayPerfiles($db, $filtro = null, $id_sistema = null) // ~X2C
 482     {
 483         //FORECHEO LO QUE ME DEVUELVA GET PERMISOS
 484         $rta = array ();
 485         foreach (SAMURAI_Perfil::getPerfiles($db, $filtro, $id_sistema) as $perfil) {
 486             $rta[$perfil->getId()] = $perfil->getDescripcion();
 487         }
 488         return $rta;
 489     }
 490     // -X2C
 491
 492     // +X2C Operation 358
 493     /**
 494      * Valida la existencia de un perfil con la descripcion que se pasa por parametro. Devuelve true si existe y false si no existe.
 495      *
 496      * @param  SAMURAI_DB $db Base de Datos
 497      * @param  string $descripcion Descripcion a comparar
 498      *
 499      * @return bool
 500      * @access public
 501      * @static
 502      */
 503     function existePerfil($db, $descripcion) // ~X2C
 504     {
 505         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 506         $tmp = $sql['obtener_datos_perfil'].$sql['obtener_datos_perfil3'];
 507         $dbh = $db->prepare($tmp);
 508         $tmp = array ($descripcion);
 509         $res = $db->execute($dbh,$tmp);
 510         $re  = $res->fetchRow();
 511         if (is_null($re)) {
 512             return false;
 513         }
 514         else {
 515             return true;
 516         }
 517     }
 518     // -X2C
 519
 520     // +X2C Operation 360
 521     /**
 522      * Valida la existencia de una asociacion entre el perfil y el sistema seleccionado. Devuelve true si existe y false en caso contraro.
 523      *
 524      * @param  SAMURAI_DB $db Base de Datos
 525      * @param  int $id_perfil Identificador del perfil con el cual hacer la comparacion
 526      * @param  int $id_sistema Identificador del sistema con el cual hacer la compararcion
 527      *
 528      * @return bool
 529      * @access public
 530      * @static
 531      */
 532     function existeAsociacion($db, $id_perfil, $id_sistema) // ~X2C
 533     {
 534         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 535         $tmp = $sql['verificar_asociacion'];
 536         $dbh = $db->prepare($tmp);
 537         $tmp = array ($id_perfil, $id_sistema);
 538         $res = $db->execute($dbh,$tmp);
 539         $re  = $res->fetchRow();
 540         if (is_null($re)) {
 541             return false;
 542         }
 543         else {
 544             return true;
 545         }
 546     }
 547     // -X2C
 548
 549     // +X2C Operation 362
 550     /**
 551      * Se encarga de guardar la relacion entre perfiles - permisos - sistemas
 552      *
 553      * @return mixed
 554      * @access protected
 555      */
 556     function _guardarPermisos() // ~X2C
 557     {
 558         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 559         //VERIFICO QUE NO HAYA UN PERFIL CON LOS MISMOS PERMISOS YA ASIGNADO AL SISTEMA
 560         $res = $this->_verifPermisos();
 561         if (PEAR::isError($res)) {
 562             return $res;
 563         }
 564
 565         //GRABO EN PERM_PERFIL_SIST
 566         $datos = array ('id_permiso', 'id_perfil', 'id_sistema', 'observaciones', 'responsable');
 567         $re = $this->_db->autoPrepare('samurai.perm_perfil_sist', $datos, DB_AUTOQUERY_INSERT);
 568         foreach ($this->getPermisos() as $permiso) {
 569             list($id, $obs) = split ('##',$permiso);
 570             $datos = array ($id, $this->getId(), $this->_idSistema, $obs, $this->getResponsable());
 571             $res = $this->_db->execute($re, $datos);
 572             if (PEAR::isError($res)) {
 573                 return $res;
 574             }
 575         }
 576     }
 577     // -X2C
 578
 579     // +X2C Operation 363
 580     /**
 581      * Borra la asociacion de un perfil de un sistema con sus permisos
 582      *
 583      * @return mixed
 584      * @access protected
 585      */
 586     function _borrarPermisos() // ~X2C
 587     {
 588         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 589         $tmp = $sql['borrar_permisos'];
 590         $dbh = $this->_db->prepare($tmp);
 591         $tmp = array ($this->getId(), $this->_idSistema);
 592         return $this->_db->execute($dbh,$tmp);
 593     }
 594     // -X2C
 595
 596     // +X2C Operation 376
 597     /**
 598      * Verifica si se puede insertar
 599      *
 600      * @return mixed
 601      * @access protected
 602      */
 603     function _verifPermisos() // ~X2C
 604     {
 605         //VERIFICO QUE NO HAYA UN PERFIL CON LOS MISMOS PERMISOS YA ASIGNADO AL SISTEMA
 606         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 607         $tmp = $sql['verif_perm_perfil_sist'];
 608         $dbh = $this->_db->prepare($tmp);
 609         $tmp = array ($this->_idSistema);
 610         $res = $this->_db->execute($dbh,$tmp);
 611         $perm = array();
 612         while ($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
 613             $perm[$re['id_perfil']][] = $re['id_permiso'].'##'.$re['observaciones'];
 614         }
 615         foreach ($perm as $key => $p) {
 616             $rta1 = array_diff($p, $this->getPermisos());
 617             $rta2 = array_diff($this->getPermisos(), $p);
 618             if (!$rta1 && !$rta2) {
 619                 $perf = new SAMURAI_Perfil($this->_db, $key, $this->_idSistema);
 620                 if ($perf->getDescripcion() != $this->getDescripcion()) {
 621                     return new PEAR_Error("El perfil \"".$perf->getDescripcion()."\" contiene los mismos permisos.");
 622                 }
 623             }
 624         }
 625         return true;
 626     }
 627     // -X2C
 628
 629 } // -X2C Class :SAMURAI_Perfil
 630
 631 ?>