lib/SAMURAI/Sistema.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 require_once 'SAMURAI/DB.php';
  29 require_once 'Date.php';
  30
  31 /**
  32  * Clase para el manejo de los sistemas.
  33  *
  34  * @access public
  35  */
  36 class SAMURAI_Sistema {
  37     /**
  38      * Identificador del sistema.
  39      *
  40      * @var    int $id
  41      * @access protected
  42      */
  43     var $_id = null;
  44
  45     /**
  46      * Nombre del sistema.
  47      *
  48      * @var    string $nombre
  49      * @access protected
  50      */
  51     var $_nombre = null;
  52
  53     /**
  54      * Descripcion del sistema.
  55      *
  56      * @var    string $descripcion
  57      * @access protected
  58      */
  59     var $_descripcion = null;
  60
  61     /**
  62      * Fecha en la cual se inicio el sistema.
  63      *
  64      * @var    date $fecha_inicio
  65      * @access protected
  66      */
  67     var $_fecha_inicio = null;
  68
  69     /**
  70      * Fecha en la cual se dio por terminado el desarrollo del sistema.
  71      *
  72      * @var    date $fecha_fin
  73      * @access protected
  74      */
  75     var $_fecha_fin = null;
  76
  77     /**
  78      * Fecha de implementacion del sistema.
  79      *
  80      * @var    date $fecha_implementacion
  81      * @access protected
  82      */
  83     var $_fecha_implementacion = null;
  84
  85     /**
  86      * Texto con los datos del o de los contacto/s en el area usuario.
  87      *
  88      * @var    string $contacto
  89      * @access protected
  90      */
  91     var $_contacto = null;
  92
  93     /**
  94      * Objeto Samurai_DB
  95      *
  96      * @var    SAMURAI_DB $db
  97      * @access protected
  98      */
  99     var $_db;
 100
 101     /**
 102      * Login del responsable de los ultimos cambios del sistema.
 103      *
 104      * @var    string $responsable
 105      * @access protected
 106      */
 107     var $_responsable = null;
 108
 109     /**
 110      * Array asociativo (id - descripcion) con los permisos asociados al sistema.
 111      *
 112      * @var    array $permisos
 113      * @access protected
 114      */
 115     var $_permisos = null;
 116
 117     /**
 118      * Array con los permisos asociados al sistema
 119      *
 120      * @var    array $asociaciones
 121      * @access protected
 122      */
 123     var $_asociaciones = null;
 124
 125     /**
 126      * indica si el sistema esta activo o no.
 127      *
 128      * @var    int $estado
 129      * @access protected
 130      */
 131     var $_estado = 1;
 132
 133     /**
 134      * Gets Asociaciones.
 135      *
 136      * @return array
 137      * @access public
 138      */
 139     function getAsociaciones()
 140     {
 141         return $this->_asociaciones;
 142     }
 143
 144     /**
 145      * Sets Asociaciones.
 146      *
 147      * @param  array $asociaciones Asociaciones.
 148      *
 149      * @return void
 150      * @access public
 151      */
 152     function setAsociaciones($asociaciones)
 153     {
 154         $this->_asociaciones = $asociaciones;
 155     }
 156
 157     /**
 158      * Gets Estado.
 159      *
 160      * @return int
 161      * @access public
 162      */
 163     function getEstado()
 164     {
 165         return $this->_estado;
 166     }
 167
 168     /**
 169      * Sets Estado.
 170      *
 171      * @param  int $estado Estado.
 172      *
 173      * @return void
 174      * @access public
 175      */
 176     function setEstado($estado)
 177     {
 178         $this->_estado = $estado;
 179     }
 180
 181     /**
 182      * Constructor. Si recibe como parametro el identificador busca en la DB los datos.
 183      *
 184      * @param  SAMURAI_DB &$db Objeto Conexion
 185      * @param  int $id Identificador del sistema
 186      *
 187      * @return void
 188      * @access public
 189      */
 190     function SAMURAI_Sistema(&$db, $id = null)
 191     {
 192         $this->_db =& $db;
 193         $this->_id = $id;
 194         if (!is_null($id)) {
 195             $this->_obtenerDatosDb();
 196         }
 197     }
 198
 199     /**
 200      * Devuelve el identificador del sistema.
 201      *
 202      * @return int
 203      * @access public
 204      */
 205     function getId()
 206     {
 207         return $this->_id;
 208     }
 209
 210     /**
 211      * Devuelve el nombre del sistema.
 212      *
 213      * @return string
 214      * @access public
 215      */
 216     function getNombre()
 217     {
 218         return $this->_nombre;
 219     }
 220
 221     /**
 222      * Devuelve la descrpcion del sistema.
 223      *
 224      * @return string
 225      * @access public
 226      */
 227     function getDescripcion()
 228     {
 229         return $this->_descripcion;
 230     }
 231
 232     /**
 233      * Devuelve la fecha de inicio del sistema.
 234      *
 235      * @return &date
 236      * @access public
 237      */
 238     function &getFechaInicio()
 239     {
 240         if ($this->_fecha_inicio) {
 241             return new Date ($this->_fecha_inicio.' 00:00:00');
 242         }
 243         else {
 244             return null;
 245         }
 246     }
 247
 248     /**
 249      * Devuelve la fecha de finalizacion del sistema.
 250      *
 251      * @return &date
 252      * @access public
 253      */
 254     function &getFechaFin()
 255     {
 256         if ($this->_fecha_fin) {
 257             return new Date ($this->_fecha_fin.' 00:00:00');
 258         }
 259         else {
 260             return null;
 261         }
 262     }
 263
 264     /**
 265      * Devuelve la fecha de implementacion del sistema.
 266      *
 267      * @return &date
 268      * @access public
 269      */
 270     function &getFechaImplementacion()
 271     {
 272         if ($this->_fecha_implementacion) {
 273             return new Date ($this->_fecha_implementacion.' 00:00:00');
 274         }
 275         else {
 276             return null;
 277         }
 278     }
 279
 280     /**
 281      * Devuelve el contacto del sistema.
 282      *
 283      * @return string
 284      * @access public
 285      */
 286     function getContacto()
 287     {
 288         return $this->_contacto;
 289     }
 290
 291     /**
 292      * Setea el nombre del sistema.
 293      *
 294      * @param  string $nombre Nombre del sistema.
 295      *
 296      * @return void
 297      * @access public
 298      */
 299     function setNombre($nombre = null)
 300     {
 301         $this->_nombre = $nombre;
 302     }
 303
 304     /**
 305      * Setea la descripcion del sistema.
 306      *
 307      * @param  string $descripcion Descripcion del sistema.
 308      *
 309      * @return void
 310      * @access public
 311      */
 312     function setDescripcion($descripcion = null)
 313     {
 314         $this->_descripcion = $descripcion;
 315     }
 316
 317     /**
 318      * Setea la fecha de inicio del sistema.
 319      *
 320      * @param  date $fecha Fecha de inicio del sistema
 321      *
 322      * @return void
 323      * @access public
 324      */
 325     function setFechaInicio($fecha = null)
 326     {
 327         if ($fecha && $fecha != '0000-00-00') {
 328             $this->_fecha_inicio = $fecha;
 329         }
 330         else {
 331             $this->_fecha_inicio = null;
 332         }
 333     }
 334
 335     /**
 336      * Setea la fecha de finalizacion del sistema.
 337      *
 338      * @param  date $fecha Fecha de finalizacion del sistema.
 339      *
 340      * @return void
 341      * @access public
 342      */
 343     function setFechaFin($fecha = null)
 344     {
 345         if ($fecha && $fecha != '0000-00-00') {
 346             $this->_fecha_fin = $fecha;
 347         }
 348         else {
 349             $this->_fecha_fin = null;
 350         }
 351     }
 352
 353     /**
 354      * Setea la fecha de implementacion del sistema.
 355      *
 356      * @param  date $fecha Fecha de implementacion del sistema.
 357      *
 358      * @return void
 359      * @access public
 360      */
 361     function setFechaImplementacion($fecha = null)
 362     {
 363         if ($fecha && $fecha != '0000-00-00') {
 364             $this->_fecha_implementacion = $fecha;
 365         }
 366         else {
 367             $this->_fecha_implementacion = null;
 368         }
 369
 370     }
 371
 372     /**
 373      * Setea el contacto del sistema.
 374      *
 375      * @param  string $contacto Texto con la informacion del contacto.
 376      *
 377      * @return void
 378      * @access public
 379      */
 380     function setContacto($contacto = null)
 381     {
 382         $this->_contacto = $contacto;
 383     }
 384
 385     /**
 386      * Obtiene los datos del sistema de la DB.
 387      *
 388      * @return void
 389      * @access protected
 390      */
 391     function _obtenerDatosDb()
 392     {
 393         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 394         $tmp = $sql['obtener_datos_sistema'].$sql['obtener_datos_sistema2'];
 395         $dbh = $this->_db->prepare($tmp);
 396         $tmp = array ($this->getId());
 397         $res = $this->_db->execute($dbh,$tmp);
 398
 399         if ($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
 400             if (isset($re['nombre_sistema'])) {
 401                 $this->setNombre($re['nombre_sistema']);
 402             }
 403             if (isset($re['desc_sistema'])) {
 404                $this->setDescripcion($re['desc_sistema']);
 405             }
 406             if (isset($re['fecha_inicio'])) {
 407                 $this->setFechaInicio($re['fecha_inicio']);
 408             }
 409             if (isset($re['fecha_fin'])) {
 410                 $this->setFechaFin($re['fecha_fin']);
 411             }
 412             if (isset($re['fecha_implementacion'])) {
 413                 $this->setFechaImplementacion($re['fecha_implementacion']);
 414             }
 415             if (isset($re['contacto'])) {
 416                 $this->setContacto($re['contacto']);
 417             }
 418             if (isset($re['responsable'])) {
 419                 $this->setResponsable($re['responsable']);
 420             }
 421             if (isset($re['estado'])) {
 422                 $this->setEstado($re['estado']);
 423             }
 424         }
 425         $tmp = $sql['obtener_permisos'];
 426         $tmp.= $sql['borrar_permisos2'];
 427         $dbh = $this->_db->prepare($tmp);
 428         $tmp = array ($this->getId(),'');
 429         $res = $this->_db->execute($dbh,$tmp);
 430         $tmp  = array();
 431         $i = 0;
 432         while ($re = $res->fetchRow(DB_FETCHMODE_ORDERED)) {
 433             $tmp[] = $re['0'];
 434             $i++;
 435         }
 436         $this->_permisos = $tmp;
 437         $tmp = $sql['obtener_permisos'];
 438         $tmp.= $sql['obtener_permisos2'];
 439         $dbh = $this->_db->prepare($tmp);
 440         $tmp = array ($this->getId());
 441         $res = $this->_db->execute($dbh,$tmp);
 442         $tmp  = array();
 443         $i = 0;
 444         while ($re = $res->fetchRow(DB_FETCHMODE_ORDERED)) {
 445             $tmp[$i]['id']   = $re['0'];
 446             $tmp[$i]['obs']  = $re['1'];
 447             $tmp[$i]['desc'] = $re['2'];
 448             $i++;
 449         }
 450         $this->_asociaciones = $tmp;
 451     }
 452
 453     /**
 454      * Guarda la informacion del sistema en la base.
 455      *
 456      * @param  string $accion Accion a realizar. Grabar, modificar o eliminar
 457      *
 458      * @return void
 459      * @access public
 460      */
 461     function guardarDatos($accion = 'grabar')
 462     {
 463         $accion = strtolower($accion);
 464         switch ($accion)  {
 465             case 'grabar':
 466                 $res = $this->_grabarDb();
 467                 break;
 468             case 'modificar':
 469                 $res = $this->_modificarDb();
 470                 break;
 471             case 'eliminar':
 472                 $res = $this->_borrarDb();
 473                 break;
 474         }
 475         return $res;
 476     }
 477
 478     /**
 479      * Devuelve el login del responsable de los ultimos cambios
 480      *
 481      * @return string
 482      * @access public
 483      */
 484     function getResponsable()
 485     {
 486         return $this->_responsable;
 487     }
 488
 489     /**
 490      * Setea el login del responsable de los ultimos cambios del sistema
 491      *
 492      * @param  string $responsable String con el login del responsable del cambio
 493      *
 494      * @return void
 495      * @access public
 496      */
 497     function setResponsable($responsable = null)
 498     {
 499         $this->_responsable = $responsable;
 500     }
 501
 502     /**
 503      * Devuelve un array asociativo con los identificadores de los permisos
 504      *
 505      * @return array
 506      * @access public
 507      */
 508     function getIdPermisos()
 509     {
 510         return $this->_permisos;
 511     }
 512
 513     /**
 514      * Setea los permisos de un sistema
 515      *
 516      * @param  int $permisos Array asociativo con los permisos
 517      *
 518      * @return void
 519      * @access public
 520      */
 521     function setPermisos($permisos = null)
 522     {
 523         $this->_permisos = $permisos;
 524     }
 525
 526     /**
 527      * @return int
 528      * @access public
 529      */
 530     function getMaxIdSistema()
 531     {
 532         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 533         $dbh = $this->_db->prepare($sql['obtener_max_id_sistemas']);
 534         $res = $this->_db->execute($dbh);
 535         $re = $res->fetchrow(DB_FETCHMODE_ASSOC);
 536         $res->free();
 537         return $re['id_sistema'];
 538     }
 539
 540     /**
 541      * Graba los datos en la Base de Datos
 542      *
 543      * @return void
 544      * @access protected
 545      */
 546     function _grabarDb()
 547     {
 548         $idSistema = $this->_db->nextId('sistema');
 549         $fecha_inicio         = $this->getFechaInicio();
 550         $fecha_fin            = $this->getFechaFin();
 551         $fecha_implementacion = $this->getFechaImplementacion();
 552         //USO SECUENCIAS Y AUTOEXECUTE
 553         //Grabo el sistema
 554         $datos = array(
 555                     'id_sistema'            => $idSistema,
 556                     'nombre_sistema'        => $this->getNombre(),
 557                     'desc_sistema'          => $this->getDescripcion(),
 558                     'fecha_inicio'          => $fecha_inicio         ? $fecha_inicio->format("%Y-%m-%d")         : null,
 559                     'fecha_fin'             => $fecha_fin            ? $fecha_fin->format("%Y-%m-%d")            : null,
 560                     'fecha_implementacion'  => $fecha_implementacion ? $fecha_implementacion->format("%Y-%m-%d") : null,
 561                     'contacto'              => $this->getContacto(),
 562                     'responsable'           => $this->getResponsable(),
 563                     'estado'                => $this->getEstado()
 564                 );
 565         $res = $this->_db->autoExecute('samurai.sistema', $datos, DB_AUTOQUERY_INSERT);
 566
 567         if (PEAR::isError($res)) {
 568             return $res;
 569         }
 570         //Grabo los permisos
 571         $res = $this->_grabarPermisosDb($idSistema);
 572         if (PEAR::isError($res)) {
 573             return $res;
 574         }
 575         $this->_id = $idSistema;
 576     }
 577
 578     /**
 579      * Borra los datos de la base de datos
 580      *
 581      * @return void
 582      * @access protected
 583      */
 584     function _borrarDb()
 585     {
 586         $idSistema   = $this->getId();
 587         $responsable = $this->getResponsable();
 588         //Cambio el estado al sistema
 589         $datos = array( 'responsable' => $responsable,
 590                         'estado'      => 0
 591                 );
 592         $res = $this->_db->autoExecute('samurai.sistema', $datos, DB_AUTOQUERY_UPDATE, 'id_sistema = '.$idSistema);
 593         if (PEAR::isError($res)) {
 594             return $res;
 595         }
 596
 597         if ($idSistema == @$_SESSION['samurai']['id_sistema']){
 598             $_SESSION['samurai']['id_sistema'] = '';
 599         }
 600     }
 601
 602     /**
 603      * Modifica los datos en base
 604      *
 605      * @return void
 606      * @access protected
 607      */
 608     function _modificarDb()
 609     {
 610         //Grabo las modificaciones al sistema
 611         $idSistema            = $this->getId();
 612         $fecha_inicio         = $this->getFechaInicio();
 613         $fecha_fin            = $this->getFechaFin();
 614         $fecha_implementacion = $this->getFechaImplementacion();
 615         //USO SECUENCIAS Y AUTOEXECUTE
 616         //Grabo el sistema
 617         $datos = array(
 618                     'nombre_sistema'        => $this->getNombre(),
 619                     'desc_sistema'          => $this->getDescripcion(),
 620                     'fecha_inicio'          => $fecha_inicio         ? $fecha_inicio->format("%Y-%m-%d")         : null,
 621                     'fecha_fin'             => $fecha_fin            ? $fecha_fin->format("%Y-%m-%d")            : null,
 622                     'fecha_implementacion'  => $fecha_implementacion ? $fecha_implementacion->format("%Y-%m-%d") : null,
 623                     'contacto'              => $this->getContacto(),
 624                     'responsable'           => $this->getResponsable(),
 625                     'estado'                => $this->getEstado()
 626                 );
 627         $res = $this->_db->autoExecute('samurai.sistema', $datos, DB_AUTOQUERY_UPDATE, 'id_sistema = '.$idSistema);
 628         if (PEAR::isError($res)) {
 629             return $res;
 630         }
 631         //Borro los permisos que no tengan observaciones
 632         $res = $this->_borrarPermisosDb($idSistema, '');
 633         if (PEAR::isError($res)) {
 634             return $res;
 635         }
 636         //Grabo los permisos que selecciono
 637         $res = $this->_grabarPermisosDb($idSistema);
 638         if (PEAR::isError($res)) {
 639             return $res;
 640         }
 641     }
 642
 643     /**
 644      * Graba los permisos del sistema en perm_sist
 645      *
 646      * @param  int $idSistema Identificador del sistema
 647      *
 648      * @return void
 649      * @access protected
 650      */
 651     function _grabarPermisosDb($idSistema)
 652     {
 653         $datos = array ('id_permiso','id_sistema','responsable');
 654         $re = $this->_db->autoPrepare('samurai.perm_sist', $datos, DB_AUTOQUERY_INSERT);
 655         if (isset($this->_permisos)) {
 656             foreach ($this->_permisos as $permiso) {
 657                 $datos = array ($permiso, $idSistema, $this->getResponsable());
 658                 $res = $this->_db->execute($re, $datos);
 659                 if (PEAR::isError($res)) {
 660                     return $res;
 661                 }
 662             }
 663         }
 664
 665     }
 666
 667     /**
 668      * Borra los permisos que tenga asociado el sistema segun el criterio de observaciones
 669      *
 670      * @param  int $idSistema Identificador del sistema
 671      * @param  bool $observaciones Null u observacion de la asociacion a borrar
 672      * @param  int $idPermiso Identificador del permiso a borrar
 673      *
 674      * @return void
 675      * @access protected
 676      */
 677     function _borrarPermisosDb($idSistema, $observaciones = null, $idPermiso = null)
 678     {
 679         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 680         $datos[] = $idSistema;
 681         $tmp = $sql['borrar_permisos'];
 682         if (isset($observaciones)) {
 683             $tmp.= $sql['borrar_permisos2'];
 684             $datos[] = $observaciones;
 685         }
 686         if (isset($idPermiso)) {
 687             $tmp.= $sql['borrar_permisos3'];
 688             $datos[] = $idPermiso;
 689         }
 690         $dbh = $this->_db->prepare($tmp);
 691         $res = $this->_db->execute($dbh, $datos);
 692         if (PEAR::isError($res)) {
 693             return $res;
 694         }
 695     }
 696
 697     /**
 698      * Guarda en base las nuevas asociaciones que se van cargando y actualiza los datos del sistema.
 699      *
 700      * @param  int $idPermiso Identificador del Permiso
 701      * @param  string $observacion Observacion a agregar
 702      *
 703      * @return bool
 704      * @access public
 705      */
 706     function guardarAsociacion($idPermiso, $observacion = '')
 707     {
 708         if (!$this->_existeAsociacion($idPermiso, $observacion)) {
 709             //Guardo la asociacion
 710             //Grabo el sistema
 711             $datos = array(
 712                         'id_permiso'    => $idPermiso,
 713                         'id_sistema'    => $this->getId(),
 714                         'observaciones' => $observacion,
 715                         'responsable'   => $this->getResponsable(),
 716                     );
 717             $res = $this->_db->autoExecute('samurai.perm_sist', $datos, DB_AUTOQUERY_INSERT);
 718             //Recargo los datos del sistema
 719             $this->_obtenerDatosDb();
 720             return null;
 721         }
 722         else {
 723             return new PEAR_Error('La Asociacion ya existe.');
 724         }
 725     }
 726
 727     /**
 728      * Elimina una asociacion de la base, y actualiza los datos del sistema.
 729      *
 730      * @param  int $idPermiso Identificador del permiso a borrar
 731      * @param  string $observacion Observacion de la asociacion a borrar (Puede ser vacia)
 732      *
 733      * @return bool
 734      * @access public
 735      */
 736     function eliminarAsociacion($idPermiso, $observacion = '')
 737     {
 738         //TODO Arreglar el asco este
 739         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 740         $res = '';
 741         //Obtengo los id de los perfiles del permiso en el sistema
 742         $tmp = $sql['ea_obt_idperfil'];
 743         $dbh = $this->_db->prepare($tmp);
 744         $res = $this->_db->execute($dbh, array ($idPermiso, $observacion, $this->getId()));
 745         if (PEAR::isError($res)) {
 746             return $res;
 747         }
 748         $i = 0;
 749         $tmp = '';
 750         while ($re = $res->fetchRow(DB_FETCHMODE_ORDERED)) {
 751             $tmp[] = $re['0'];
 752             $i++;
 753         }
 754         $PERFILES = $tmp;
 755         //Borro el permiso de los perfiles del sistema
 756         $tmp = $sql['ea_del_perm_perfil_sist'];
 757         $dbh = $this->_db->prepare($tmp);
 758         $res = $this->_db->execute($dbh, array ($idPermiso, $observacion, $this->getId()));
 759         if (PEAR::isError($res)) {
 760             return $res;
 761         }
 762         //Verifico si era el unico permiso de cada uno de los perfiles en los que estaba asignado
 763         if (@$PERFILES) {
 764             foreach ($PERFILES as $perfil) {
 765                 //Cuento
 766                 $tmp = $sql['ea_obt_cuenta_perfil'];
 767                 $dbh = $this->_db->prepare($tmp);
 768                 $res = $this->_db->execute($dbh, array ($perfil, $this->getId()));
 769                 if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && $re['cuenta'] == 0) {
 770                     //Borro perfil_sist
 771                     $tmp = $sql['ea_del_perfil_sist'];
 772                     $dbh = $this->_db->prepare($tmp);
 773                     $res = $this->_db->execute($dbh, array ($perfil, $this->getId()));
 774                     if (PEAR::isError($res)) {
 775                         return $res;
 776                     }
 777                     //Borro perfil_sist_usuario
 778                     $tmp = $sql['ea_del_perfil_sist_usuario'];
 779                     $dbh = $this->_db->prepare($tmp);
 780                     $res = $this->_db->execute($dbh, array ($perfil, $this->getId()));
 781                     if (PEAR::isError($res)) {
 782                         return $res;
 783                     }
 784                     //Verifico si hay otro sistema usando este perfil
 785                     $tmp = $sql['ea_obt_cuenta_perfil_sist'];
 786                     $dbh = $this->_db->prepare($tmp);
 787                     $res = $this->_db->execute($dbh, array ($perfil));
 788                     if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && $re['cuenta'] == 0){
 789                         $tmp = $sql['ea_del_perfil'];
 790                         $dbh = $this->_db->prepare($tmp);
 791                         $res = $this->_db->execute($dbh, array ($perfil));
 792                         if (PEAR::isError($res)) {
 793                             return $res;
 794                         }
 795                     }
 796                 }
 797             }
 798         }
 799         //Borro la asociacion perm_sist
 800         $res = $this->_borrarPermisosDb($this->getId(), $observacion, $idPermiso);
 801         if (PEAR::isError($res)) {
 802             return $res;
 803         }
 804         //Recargo los datos del sistema
 805         $this->_obtenerDatosDb();
 806     }
 807
 808     /**
 809      * Actualiza los datos de la asociacion en la base de datos.
 810      *
 811      * @param  int $idPermiso Identificador del permiso
 812      * @param  string $observacion Observacion a insertar
 813      * @param  string $obs_ant Observacion anterior
 814      *
 815      * @return bool
 816      * @access public
 817      */
 818     function modificarAsociacion($idPermiso, $observacion = '', $obs_ant = '')
 819     {
 820         //Busco la nueva asociacion
 821         if (!$this->_existeAsociacion($idPermiso, $observacion)) {
 822             //Actualizo la asociacion
 823              $datos = array(
 824                         'id_permiso'    => $idPermiso,
 825                         'id_sistema'    => $this->getId(),
 826                         'observaciones' => $observacion,
 827                         'responsable'   => $this->getResponsable(),
 828                     );
 829             $this->_db->autoExecute('samurai.perm_sist',
 830                                     $datos,
 831                                     DB_AUTOQUERY_UPDATE,
 832                                     'id_sistema = '.$this->getId().' AND id_permiso = '.$idPermiso.' AND observaciones =\''.$obs_ant.'\'');
 833
 834             //Recargo los datos del sistema
 835             $this->_obtenerDatosDb();
 836             return null;
 837         }
 838         else {
 839             return new PEAR_Error('La Asociacion ya existe.');
 840         }
 841     }
 842
 843     /**
 844      * Chequea si existe la asociacion
 845      *
 846      * @param  int $idPermiso Id del permiso a chequear
 847      * @param  string $observacion Observacion a chequear
 848      *
 849      * @return bool
 850      * @access protected
 851      */
 852     function _existeAsociacion($idPermiso, $observacion)
 853     {
 854         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 855         $tmp = $sql['obtener_permisos'].$sql['obtener_permisos3'].$sql['obtener_permisos4'];
 856         $dbh = $this->_db->prepare($tmp);
 857         $tmp = array ($this->getId(),$idPermiso,$observacion);
 858         $res = $this->_db->execute($dbh,$tmp);
 859         $re  = $res->fetchRow();
 860
 861         if (is_null($re)) {
 862             return false;
 863         }
 864         else {
 865             return true;
 866         }
 867     }
 868
 869     /**
 870      * Devuelve el array de sistemas
 871      *
 872      * @param  SAMURAI_DB &$db Base de Datos
 873      * @param  bool $activos Indica si se deben buscar solamente los sistemas activos
 874      *
 875      * @return array(Sistema)
 876      * @access public
 877      * @static
 878      */
 879     function getSistemas(&$db, $activos = true)
 880     {
 881         $rta = array ();
 882         foreach (SAMURAI_Sistema::_getIdSistemas($db, $activos) as $id) {
 883             $tmp = new SAMURAI_Sistema($db,$id);
 884             array_push($rta, $tmp);
 885         }
 886         return $rta;
 887     }
 888
 889     /**
 890      * Devuleve un array con los identificadores de todos los sistemas.
 891      *
 892      * @param  SAMURAI_DB &$db Base de Datos
 893      * @param  bool $activos Indica si se deben buscar solamente los sistemas activos
 894      *
 895      * @return array(int)
 896      * @access protected
 897      * @static
 898      */
 899     function _getIdSistemas(&$db, $activos = true)
 900     {
 901         //OBTENGO LOS ID DE LA BASE
 902         $rta = array();
 903         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 904         $consulta = $sql['obtener_datos_sistema'];
 905         if (@$activos) {
 906             $consulta.= $sql['obtener_datos_sistema3'];
 907         }
 908         $consulta.= $sql['obtener_datos_sistema4'];
 909         $dbh = $db->prepare($consulta);
 910         $res = $db->execute($dbh);
 911         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 912             array_push($rta,$re['id_sistema']);
 913         }
 914         $res->free();
 915         return $rta;
 916     }
 917
 918     /**
 919      * Devuelve un array asociativo en donde la clave es el identificador y el valor es el nombre del sistema
 920      *
 921      * @param  SAMURAI_DB &$db Base de Datos
 922      * @param  bool $activos Indica si se deben buscar solamente los sistemas activos
 923      *
 924      * @return array()
 925      * @access public
 926      * @static
 927      */
 928     function getArraySistemas(&$db, $activos = true)
 929     {
 930         $rta = array ();
 931         foreach (SAMURAI_Sistema::getSistemas($db, $activos) as $sistema) {
 932             $rta[$sistema->getId()] = $sistema->getNombre();
 933         }
 934         return $rta;
 935     }
 936
 937     /**
 938      * Devuelve un array asociativo en donde la clave es el identificador y el valor es el nombre del sistema. Solo devuelve aquellos sistemas en los cuales el usuario tiene permisos.
 939      *
 940      * @param  DB &$DB Conexion a la base de datos
 941      *
 942      * @return array()
 943      * @access public
 944      */
 945     function getArraySistemasSeleccionar(&$DB)
 946     {
 947         $rta = array();
 948         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 949         //Verifico si tiene permiso developer en samurai
 950         $consulta = $sql['sistemas_seleccionar2'];
 951         $dbh = $DB->prepare($consulta);
 952         $res = $DB->execute($dbh, array(SAMURAI_PERM, $_SESSION['usuario'],
 953                     SAMURAI_PERM_DEVELOPER));
 954         $re = $res->fetchrow(DB_FETCHMODE_ASSOC);
 955         if ($re['cuenta']) {
 956             $consulta = $sql['obtener_datos_sistema'];
 957             $consulta.= $sql['obtener_datos_sistema3'];
 958             $consulta.= $sql['obtener_datos_sistema4'];
 959             $dbh = $DB->prepare($consulta);
 960             $res = $DB->execute($dbh);
 961             while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 962                 $rta[$re['id_sistema']] = $re['nombre_sistema'];
 963             }
 964             $res->free();
 965             return $rta;
 966         }
 967         //Si no tiene permiso developer en samurai le muestro solo aquellos
 968         //sistemas en los cuales puede trabajar
 969         $consulta = $sql['sistemas_seleccionar'];
 970         $dbh = $DB->prepare($consulta);
 971         $res = $DB->execute($dbh, array($_SESSION['usuario'],
 972                     SAMURAI_PERM_PERFIL_ALTA, SAMURAI_PERM_PERFIL_BAJA,
 973                     SAMURAI_PERM_PERFIL_MODIF, SAMURAI_PERM_USUARIO_ALTA,
 974                     SAMURAI_PERM_USUARIO_BAJA, SAMURAI_PERM_USUARIO_MODIF));
 975         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 976             $rta[$re['id_sistema']] = $re['nombre_sistema'];
 977         }
 978         $res->free();
 979
 980         return $rta;
 981     }
 982
 983 }
 984 ?>