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