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