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 = 0;
 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'                => 1
 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                 );
 674         $res = $this->_db->autoExecute('samurai.sistema', $datos, DB_AUTOQUERY_UPDATE, 'id_sistema = '.$idSistema);
 675         if (PEAR::isError($res)) {
 676             return $res;
 677         }
 678         //Borro los permisos que no tengan observaciones
 679         $res = $this->_borrarPermisosDb($idSistema, '');
 680         if (PEAR::isError($res)) {
 681             return $res;
 682         }
 683         //Grabo los permisos que selecciono
 684         $res = $this->_grabarPermisosDb($idSistema);
 685         if (PEAR::isError($res)) {
 686             return $res;
 687         }
 688     }
 689     // -X2C
 690
 691
 692     // +X2C Operation 308
 693     /**
 694      * Graba los permisos del sistema en perm_sist
 695      *
 696      * @param  int $idSistema Identificador del sistema
 697      *
 698      * @return void
 699      * @access protected
 700      */
 701     function _grabarPermisosDb($idSistema) // ~X2C
 702     {
 703         $datos = array ('id_permiso','id_sistema','responsable');
 704         $re = $this->_db->autoPrepare('samurai.perm_sist', $datos, DB_AUTOQUERY_INSERT);
 705         if (isset($this->_permisos)) {
 706             foreach ($this->_permisos as $permiso) {
 707                 $datos = array ($permiso, $idSistema, $this->getResponsable());
 708                 $res = $this->_db->execute($re, $datos);
 709                 if (PEAR::isError($res)) {
 710                     return $res;
 711                 }
 712             }
 713         }
 714
 715     }
 716     // -X2C
 717
 718     // +X2C Operation 309
 719     /**
 720      * Borra los permisos que tenga asociado el sistema segun el criterio de observaciones
 721      *
 722      * @param  int $idSistema Identificador del sistema
 723      * @param  bool $observaciones Null u observacion de la asociacion a borrar
 724      * @param  int $idPermiso Identificador del permiso a borrar
 725      *
 726      * @return void
 727      * @access protected
 728      */
 729     function _borrarPermisosDb($idSistema, $observaciones = null, $idPermiso = null) // ~X2C
 730     {
 731         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 732         $datos[] = $idSistema;
 733         $tmp = $sql['borrar_permisos'];
 734         if (isset($observaciones)) {
 735             $tmp.= $sql['borrar_permisos2'];
 736             $datos[] = $observaciones;
 737         }
 738         if (isset($idPermiso)) {
 739             $tmp.= $sql['borrar_permisos3'];
 740             $datos[] = $idPermiso;
 741         }
 742         $dbh = $this->_db->prepare($tmp);
 743         $res = $this->_db->execute($dbh, $datos);
 744         if (PEAR::isError($res)) {
 745             return $res;
 746         }
 747     }
 748     // -X2C
 749
 750
 751     // +X2C Operation 312
 752     /**
 753      * Guarda en base las nuevas asociaciones que se van cargando y actualiza los datos del sistema.
 754      *
 755      * @param  int $idPermiso Identificador del Permiso
 756      * @param  string $observacion Observacion a agregar
 757      *
 758      * @return bool
 759      * @access public
 760      */
 761     function guardarAsociacion($idPermiso, $observacion = '') // ~X2C
 762     {
 763         if (!$this->_existeAsociacion($idPermiso, $observacion)) {
 764             //Guardo la asociacion
 765             //Grabo el sistema
 766             $datos = array(
 767                         'id_permiso'    => $idPermiso,
 768                         'id_sistema'    => $this->getId(),
 769                         'observaciones' => $observacion,
 770                         'responsable'   => $this->getResponsable(),
 771                     );
 772             $res = $this->_db->autoExecute('samurai.perm_sist', $datos, DB_AUTOQUERY_INSERT);
 773             //Recargo los datos del sistema
 774             $this->_obtenerDatosDb();
 775             return null;
 776         }
 777         else {
 778             return new PEAR_Error('La Asociacion ya existe.');
 779         }
 780     }
 781     // -X2C
 782
 783     // +X2C Operation 313
 784     /**
 785      * Elimina una asociacion de la base, y actualiza los datos del sistema.
 786      *
 787      * @param  int $idPermiso Identificador del permiso a borrar
 788      * @param  string $observacion Observacion de la asociacion a borrar (Puede ser vacia)
 789      *
 790      * @return bool
 791      * @access public
 792      */
 793     function eliminarAsociacion($idPermiso, $observacion = '') // ~X2C
 794     {
 795         //TODO Arreglar el asco este
 796         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 797         $res = '';
 798         //Obtengo los id de los perfiles del permiso en el sistema
 799         $tmp = $sql['ea_obt_idperfil'];
 800         $dbh = $this->_db->prepare($tmp);
 801         $res = $this->_db->execute($dbh, array ($idPermiso, $observacion, $this->getId()));
 802         if (PEAR::isError($res)) {
 803             return $res;
 804         }
 805         $i = 0;
 806         $tmp = '';
 807         while ($re = $res->fetchRow(DB_FETCHMODE_ORDERED)) {
 808             $tmp[] = $re['0'];
 809             $i++;
 810         }
 811         $PERFILES = $tmp;
 812         //Borro el permiso de los perfiles del sistema
 813         $tmp = $sql['ea_del_perm_perfil_sist'];
 814         $dbh = $this->_db->prepare($tmp);
 815         $res = $this->_db->execute($dbh, array ($idPermiso, $observacion, $this->getId()));
 816         if (PEAR::isError($res)) {
 817             return $res;
 818         }
 819         //Verifico si era el unico permiso de cada uno de los perfiles en los que estaba asignado
 820         if (@$PERFILES) {
 821             foreach ($PERFILES as $perfil) {
 822                 //Cuento
 823                 $tmp = $sql['ea_obt_cuenta_perfil'];
 824                 $dbh = $this->_db->prepare($tmp);
 825                 $res = $this->_db->execute($dbh, array ($perfil, $this->getId()));
 826                 if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && $re['cuenta'] == 0) {
 827                     //Borro perfil_sist
 828                     $tmp = $sql['ea_del_perfil_sist'];
 829                     $dbh = $this->_db->prepare($tmp);
 830                     $res = $this->_db->execute($dbh, array ($perfil, $this->getId()));
 831                     if (PEAR::isError($res)) {
 832                         return $res;
 833                     }
 834                     //Borro perfil_sist_usuario
 835                     $tmp = $sql['ea_del_perfil_sist_usuario'];
 836                     $dbh = $this->_db->prepare($tmp);
 837                     $res = $this->_db->execute($dbh, array ($perfil, $this->getId()));
 838                     if (PEAR::isError($res)) {
 839                         return $res;
 840                     }
 841                     //Verifico si hay otro sistema usando este perfil
 842                     $tmp = $sql['ea_obt_cuenta_perfil_sist'];
 843                     $dbh = $this->_db->prepare($tmp);
 844                     $res = $this->_db->execute($dbh, array ($perfil));
 845                     if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && $re['cuenta'] == 0){
 846                         $tmp = $sql['ea_del_perfil'];
 847                         $dbh = $this->_db->prepare($tmp);
 848                         $res = $this->_db->execute($dbh, array ($perfil));
 849                         if (PEAR::isError($res)) {
 850                             return $res;
 851                         }
 852                     }
 853                 }
 854             }
 855         }
 856         //Borro la asociacion perm_sist
 857         $res = $this->_borrarPermisosDb($this->getId(), $observacion, $idPermiso);
 858         if (PEAR::isError($res)) {
 859             return $res;
 860         }
 861         //Recargo los datos del sistema
 862         $this->_obtenerDatosDb();
 863     }
 864     // -X2C
 865
 866     // +X2C Operation 314
 867     /**
 868      * Actualiza los datos de la asociacion en la base de datos.
 869      *
 870      * @param  int $idPermiso Identificador del permiso
 871      * @param  string $observacion Observacion a insertar
 872      * @param  string $obs_ant Observacion anterior
 873      *
 874      * @return bool
 875      * @access public
 876      */
 877     function modificarAsociacion($idPermiso, $observacion = '', $obs_ant = '') // ~X2C
 878     {
 879         //Busco la nueva asociacion
 880         if (!$this->_existeAsociacion($idPermiso, $observacion)) {
 881             //Actualizo la asociacion
 882              $datos = array(
 883                         'id_permiso'    => $idPermiso,
 884                         'id_sistema'    => $this->getId(),
 885                         'observaciones' => $observacion,
 886                         'responsable'   => $this->getResponsable(),
 887                     );
 888             $this->_db->autoExecute('samurai.perm_sist',
 889                                     $datos,
 890                                     DB_AUTOQUERY_UPDATE,
 891                                     'id_sistema = '.$this->getId().' AND id_permiso = '.$idPermiso.' AND observaciones =\''.$obs_ant.'\'');
 892
 893             //Recargo los datos del sistema
 894             $this->_obtenerDatosDb();
 895             return null;
 896         }
 897         else {
 898             return new PEAR_Error('La Asociacion ya existe.');
 899         }
 900     }
 901     // -X2C
 902
 903     // +X2C Operation 315
 904     /**
 905      * Chequea si existe la asociacion
 906      *
 907      * @param  int $idPermiso Id del permiso a chequear
 908      * @param  string $observacion Observacion a chequear
 909      *
 910      * @return bool
 911      * @access protected
 912      */
 913     function _existeAsociacion($idPermiso, $observacion) // ~X2C
 914     {
 915         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 916         $tmp = $sql['obtener_permisos'].$sql['obtener_permisos3'].$sql['obtener_permisos4'];
 917         $dbh = $this->_db->prepare($tmp);
 918         $tmp = array ($this->getId(),$idPermiso,$observacion);
 919         $res = $this->_db->execute($dbh,$tmp);
 920         $re  = $res->fetchRow();
 921
 922         if (is_null($re)) {
 923             return false;
 924         }
 925         else {
 926             return true;
 927         }
 928     }
 929     // -X2C
 930
 931     // +X2C Operation 341
 932     /**
 933      * Devuelve el array de sistemas
 934      *
 935      * @param  SAMURAI_DB &$db Base de Datos
 936      * @param  bool $activos Indica si se deben buscar solamente los sistemas activos
 937      *
 938      * @return array(Sistema)
 939      * @access public
 940      * @static
 941      */
 942     function getSistemas(&$db, $activos = true) // ~X2C
 943     {
 944         $rta = array ();
 945         foreach (SAMURAI_Sistema::_getIdSistemas($db, $activos) as $id) {
 946             $tmp = new SAMURAI_Sistema($db,$id);
 947             array_push($rta, $tmp);
 948         }
 949         return $rta;
 950     }
 951     // -X2C
 952
 953     // +X2C Operation 342
 954     /**
 955      * Devuleve un array con los identificadores de todos los sistemas.
 956      *
 957      * @param  SAMURAI_DB &$db Base de Datos
 958      * @param  bool $activos Indica si se deben buscar solamente los sistemas activos
 959      *
 960      * @return array(int)
 961      * @access protected
 962      * @static
 963      */
 964     function _getIdSistemas(&$db, $activos = true) // ~X2C
 965     {
 966         //OBTENGO LOS ID DE LA BASE
 967         $rta = array();
 968         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 969         $consulta = $sql['obtener_datos_sistema'];
 970         if (@$activos) {
 971             $consulta.= $sql['obtener_datos_sistema3'];
 972         }
 973         $consulta.= $sql['obtener_datos_sistema4'];
 974         $dbh = $db->prepare($consulta);
 975         $res = $db->execute($dbh);
 976         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 977             array_push($rta,$re['id_sistema']);
 978         }
 979         $res->free();
 980         return $rta;
 981     }
 982     // -X2C
 983
 984     // +X2C Operation 343
 985     /**
 986      * Devuelve un array asociativo en donde la clave es el identificador y el valor es el nombre del sistema
 987      *
 988      * @param  SAMURAI_DB &$db Base de Datos
 989      * @param  bool $activos Indica si se deben buscar solamente los sistemas activos
 990      *
 991      * @return array()
 992      * @access public
 993      * @static
 994      */
 995     function getArraySistemas(&$db, $activos = true) // ~X2C
 996     {
 997         $rta = array ();
 998         foreach (SAMURAI_Sistema::getSistemas($db, $activos) as $sistema) {
 999             $rta[$sistema->getId()] = $sistema->getNombre();
1000         }
1001         return $rta;
1002     }
1003     // -X2C
1004
1005 } // -X2C Class :SAMURAI_Sistema
1006
1007 ?>