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