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