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        //GRABO EN PERFIL
 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             //GRABO EN PERM_PERFIL_SIST
 322             $res = $this->_guardarPermisos();
 323             if (PEAR::isError($res)) {
 324                 return $res;
 325             }
 326
 327             $datos = array (
 328                         'id_perfil'   => $idPerfil,
 329                         'desc_perfil' => $this->getDescripcion(),
 330                         'responsable' => $this->getResponsable(),
 331                     );
 332             $res = $this->_db->autoExecute('perfil', $datos, DB_AUTOQUERY_INSERT);
 333             if (PEAR::isError($res)) {
 334                 return $res;
 335             }
 336         }
 337         //GRABO EN PERFIL_SIST
 338         $datos = array ('id_perfil'   => $this->getId(),
 339                         'id_sistema'  => $_SESSION['samurai']['id_sistema'],
 340                         'tipo_perfil' => $this->getTipo(),
 341                         'responsable' => $this->getResponsable(),
 342                     );
 343         $res = $this->_db->autoExecute('perfil_sist', $datos, DB_AUTOQUERY_INSERT);
 344     }
 345     // -X2C
 346
 347     // +X2C Operation 325
 348     /**
 349      * Borra la informacion del perfil de la base
 350      *
 351      * @return mixed
 352      * @access protected
 353      */
 354     function _borrarDb() // ~X2C
 355     {
 356         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 357         //Verifico en perfil_sist_usuario
 358         $tmp = $sql['verif_perfil_sist_usuario'];
 359         $dbh = $this->_db->prepare($tmp);
 360         $datos = array ($this->getId(), $_SESSION['samurai']['id_sistema']);
 361         $res = $this->_db->execute($dbh, $datos);
 362         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && !$re['cuenta'] == 0) {
 363             return new PEAR_Error("Hay usuarios asociados al perfil seleccionado");
 364         }
 365         //Borro perm_perfil_sist
 366         $res = $this->_borrarPermisos();
 367         if (PEAR::isError($res)) {
 368             return $res;
 369         }
 370         //Borro perfil_sist
 371         $tmp = $sql['borrar_perfil_sist'];
 372         $dbh = $this->_db->prepare($tmp);
 373         $datos = array ($this->getId(), $_SESSION['samurai']['id_sistema']);
 374         $res = $this->_db->execute($dbh, $datos);
 375         if (PEAR::isError($res)) {
 376             return $res;
 377         }
 378         //Verifico en perfil_sist (Perfil asociado a otros sistemas)
 379         $tmp = $sql['verif_perfil_sist'];
 380         $dbh = $this->_db->prepare($tmp);
 381         $datos = array ($this->getId());
 382         $res = $this->_db->execute($dbh, $datos);
 383         if (PEAR::isError($res)) {
 384             return $res;
 385         }
 386         if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && $re['cuenta'] == 0) {
 387             //Borro perfil
 388             $tmp = $sql['borrar_perfil'];
 389             $dbh = $this->_db->prepare($tmp);
 390             $datos = array ($this->getId());
 391             $res = $this->_db->execute($dbh, $datos);
 392             if (PEAR::isError($res)) {
 393                 return $res;
 394             }
 395         }
 396     }
 397     // -X2C
 398
 399     // +X2C Operation 326
 400     /**
 401      * @return mixed
 402      * @access protected
 403      */
 404     function _modificarDb() // ~X2C
 405     {
 406         //Modifico la tabla perfil_sist
 407         $datos = array (
 408                     'tipo_perfil' => $this->getTipo(),
 409                     'responsable' => $this->getResponsable(),
 410         );
 411         $res = $this->_db->autoExecute('perfil_sist', $datos, DB_AUTOQUERY_UPDATE, 'id_perfil ='.$this->getId().' AND id_sistema='.$_SESSION['samurai']['id_sistema']);
 412         if (PEAR::isError($res)) {
 413             return $res;
 414         }
 415         //Modifico la tabla perm_perfil_sist
 416         $res = $this->_borrarPermisos();
 417         if (PEAR::isError($res)) {
 418             return $res;
 419         }
 420         return $this->_guardarPermisos();
 421     }
 422     // -X2C
 423
 424     // +X2C Operation 338
 425     /**
 426      * Devuleve un array con los identificadores de todos los perfiles.
 427      *
 428      * @param  SAMURAI_DB &$db Base de Datos
 429      * @param  string $filtro Fltro por descripcion del perfil
 430      * @param  int $id_sistema Identificador del sistema
 431      *
 432      * @return array(int)
 433      * @access protected
 434      * @static
 435      */
 436     function _getIdPerfiles(&$db, $filtro = null, $id_sistema = null) // ~X2C
 437     {
 438         //OBTENGO LOS ID DE LA BASE
 439         $rta = array();
 440         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 441         $consulta = $sql['obtener_id_perfiles'];
 442         if ($id_sistema) {
 443             $consulta.= $sql['obtener_id_perfiles3'];
 444         }
 445         if ($filtro) { //Verifico si se paso un filtro
 446             $tmp2 = $consulta.$sql['obtener_id_perfiles2'];
 447             //Reemplazo el filtro por ##?##
 448             $consulta = ereg_replace ('##FILTRO##', $filtro, $tmp2);
 449         }
 450         $dbh = $db->prepare($consulta);
 451         if ($id_sistema) {
 452             $tmp[] = $id_sistema;
 453             $res = $db->execute($dbh, $tmp);
 454         }
 455         else {
 456             $res = $db->execute($dbh);
 457         }
 458         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 459             array_push($rta,$re['id_perfil']);
 460         }
 461         $res->free();
 462         return $rta;
 463     }
 464     // -X2C
 465
 466     // +X2C Operation 339
 467     /**
 468      * @param  SAMURAI_DB &$db Base de datos
 469      * @param  string $filtro Filtro por nombre del perfil
 470      * @param  int $id_sistema Identificador del sistema
 471      *
 472      * @return array(Perfil)
 473      * @access public
 474      * @static
 475      */
 476     function getPerfiles(&$db, $filtro = null, $id_sistema = null) // ~X2C
 477     {
 478         $rta = array ();
 479         foreach (SAMURAI_Perfil::_getIdPerfiles($db, $filtro, $id_sistema) as $id) {
 480             $tmp = new SAMURAI_Perfil($db,$id);
 481             array_push($rta, $tmp);
 482         }
 483         return $rta;
 484     }
 485     // -X2C
 486
 487     // +X2C Operation 356
 488     /**
 489      * Devuelve la informacion de los perfiles en un array.
 490      *
 491      * @param  SAMURAI_DB $db Base de Datos
 492      * @param  string $filtro Filtro por descripcion del perfil
 493      *
 494      * @return array()
 495      * @access public
 496      * @static
 497      */
 498     function getArrayPerfiles($db, $filtro = null) // ~X2C
 499     {
 500         //FORECHEO LO QUE ME DEVUELVA GET PERMISOS
 501         $rta = array ();
 502         foreach (SAMURAI_Perfil::getPerfiles($db, $filtro) as $perfil) {
 503             $rta[$perfil->getId()] = $perfil->getDescripcion();
 504         }
 505         return $rta;
 506     }
 507     // -X2C
 508
 509     // +X2C Operation 358
 510     /**
 511      * Valida la existencia de un perfil con la descripcion que se pasa por parametro. Devuelve true si existe y false si no existe.
 512      *
 513      * @param  SAMURAI_DB $db Base de Datos
 514      * @param  string $descripcion Descripcion a comparar
 515      *
 516      * @return bool
 517      * @access public
 518      * @static
 519      */
 520     function existePerfil($db, $descripcion) // ~X2C
 521     {
 522         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 523         $tmp = $sql['obtener_datos_perfil'].$sql['obtener_datos_perfil3'];
 524         $dbh = $db->prepare($tmp);
 525         $tmp = array ($descripcion);
 526         $res = $db->execute($dbh,$tmp);
 527         $re  = $res->fetchRow();
 528         if (is_null($re)) {
 529             return false;
 530         }
 531         else {
 532             return true;
 533         }
 534     }
 535     // -X2C
 536
 537     // +X2C Operation 360
 538     /**
 539      * Valida la existencia de una asociacion entre el perfil y el sistema seleccionado. Devuelve true si existe y false en caso contraro.
 540      *
 541      * @param  SAMURAI_DB $db Base de Datos
 542      * @param  int $id_perfil Identificador del perfil con el cual hacer la comparacion
 543      * @param  int $id_sistema Identificador del sistema con el cual hacer la compararcion
 544      *
 545      * @return bool
 546      * @access public
 547      * @static
 548      */
 549     function existeAsociacion($db, $id_perfil, $id_sistema) // ~X2C
 550     {
 551         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 552         $tmp = $sql['verificar_asociacion'];
 553         $dbh = $db->prepare($tmp);
 554         $tmp = array ($id_perfil, $id_sistema);
 555         $res = $db->execute($dbh,$tmp);
 556         $re  = $res->fetchRow();
 557         if (is_null($re)) {
 558             return false;
 559         }
 560         else {
 561             return true;
 562         }
 563     }
 564     // -X2C
 565
 566     // +X2C Operation 362
 567     /**
 568      * Se encarga de guardar la relacion entre perfiles - permisos - sistemas
 569      *
 570      * @return mixed
 571      * @access protected
 572      */
 573     function _guardarPermisos() // ~X2C
 574     {
 575         //VERIFICO QUE NO HAYA UN PERFIL CON LOS MISMOS PERMISOS YA ASIGNADO AL SISTEMA
 576         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 577         $tmp = $sql['verif_perm_perfil_sist'];
 578         $dbh = $this->_db->prepare($tmp);
 579         $tmp = array ($_SESSION['samurai']['id_sistema']);
 580         $res = $this->_db->execute($dbh,$tmp);
 581         $perm = array();
 582         while ($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
 583             $perm[$re['id_perfil']][] = $re['id_permiso'].'##'.$re['observaciones'];
 584         }
 585         foreach ($perm as $p) {
 586             $rta1 = array_diff($p, $this->getPermisos());
 587             $rta2 = array_diff($this->getPermisos(), $p);
 588             if (!$rta1 && !$rta2) {
 589                 return new PEAR_Error("Ya existe un perfil con esos mismos permisos");
 590             }
 591         }
 592
 593         //GRABO EN PERM_PERFIL_SIST
 594         $datos = array ('id_permiso', 'id_perfil', 'id_sistema', 'observaciones', 'responsable');
 595         $re = $this->_db->autoPrepare('perm_perfil_sist', $datos, DB_AUTOQUERY_INSERT);
 596         foreach ($this->getPermisos() as $permiso) {
 597             list($id, $obs) = split ('##',$permiso);
 598             $datos = array ($id, $this->getId(), $_SESSION['samurai']['id_sistema'], $obs, $this->getResponsable());
 599             $res = $this->_db->execute($re, $datos);
 600             if (PEAR::isError($res)) {
 601                 return $res;
 602             }
 603         }
 604     }
 605     // -X2C
 606
 607     // +X2C Operation 363
 608     /**
 609      * Borra la asociacion de un perfil de un sistema con sus permisos
 610      *
 611      * @return mixed
 612      * @access protected
 613      */
 614     function _borrarPermisos() // ~X2C
 615     {
 616         $sql = parse_ini_file(dirname(__FILE__) . '/Perfil/consultas.ini', true);
 617         $tmp = $sql['borrar_permisos'];
 618         $dbh = $this->_db->prepare($tmp);
 619         $tmp = array ($this->getId(), $_SESSION['samurai']['id_sistema']);
 620         return $this->_db->execute($dbh,$tmp);
 621     }
 622     // -X2C
 623
 624 } // -X2C Class :SAMURAI_Perfil
 625
 626 ?>