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