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