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