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