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         //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 $key => $p) {
 589             $rta1 = array_diff($p, $this->getPermisos());
 590             $rta2 = array_diff($this->getPermisos(), $p);
 591             if (!$rta1 && !$rta2) {
 592             echo 1;
 593                 $perf = new SAMURAI_Perfil($this->_db, $key);
 594                 return new PEAR_Error("El perfil \"".$perf->getDescripcion()."\" contiene los mismos permisos.");
 595             }
 596         }
 597
 598         //GRABO EN PERM_PERFIL_SIST
 599         $datos = array ('id_permiso', 'id_perfil', 'id_sistema', 'observaciones', 'responsable');
 600         $re = $this->_db->autoPrepare('perm_perfil_sist', $datos, DB_AUTOQUERY_INSERT);
 601         foreach ($this->getPermisos() as $permiso) {
 602             list($id, $obs) = split ('##',$permiso);
 603             $datos = array ($id, $this->getId(), $_SESSION['samurai']['id_sistema'], $obs, $this->getResponsable());
 604             $res = $this->_db->execute($re, $datos);
 605             if (PEAR::isError($res)) {
 606                 return $res;
 607             }
 608         }
 609     }
 610     // -X2C
 611
 612     // +X2C Operation 363
 613     /**
 614      * Borra la asociacion de un perfil de un sistema con sus permisos
 615      *
 616      * @return mixed
 617      * @access protected
 618      */
 619     function _borrarPermisos() // ~X2C
 620     {
 621         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 622         $tmp = $sql['borrar_permisos'];
 623         $dbh = $this->_db->prepare($tmp);
 624         $tmp = array ($this->getId(), $_SESSION['samurai']['id_sistema']);
 625         return $this->_db->execute($dbh,$tmp);
 626     }
 627     // -X2C
 628
 629 } // -X2C Class :SAMURAI_Perfil
 630
 631 ?>