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 = include 'Sistema/consultas.php'; //Incluyo las consultas de este objeto nada mas.
 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             $i++;
 475         }
 476         $this->_asociaciones = $tmp;
 477     }
 478     // -X2C
 479
 480     // +X2C Operation 288
 481     /**
 482      * Guarda la informacion del sistema en la base.
 483      *
 484      * @param  string $accion Accion a realizar. Grabar, modificar o eliminar
 485      *
 486      * @return void
 487      * @access public
 488      */
 489     function guardarDatos($accion = grabar) // ~X2C
 490     {
 491         $accion = strtolower($accion);
 492         switch ($accion)  {
 493             case 'grabar':
 494                 $res = $this->_grabarDb();
 495                 break;
 496             case 'modificar':
 497                 $res = $this->_modificarDb();
 498                 break;
 499             case 'eliminar':
 500                 $res = $this->_borrarDb();
 501                 break;
 502         }
 503         return $res;
 504     }
 505     // -X2C
 506
 507     // +X2C Operation 290
 508     /**
 509      * Devuelve el login del responsable de los ultimos cambios
 510      *
 511      * @return string
 512      * @access public
 513      */
 514     function getResponsable() // ~X2C
 515     {
 516         return $this->_responsable;
 517     }
 518     // -X2C
 519
 520     // +X2C Operation 291
 521     /**
 522      * Setea el login del responsable de los ultimos cambios del sistema
 523      *
 524      * @param  string $responsable String con el login del responsable del cambio
 525      *
 526      * @return void
 527      * @access public
 528      */
 529     function setResponsable($responsable = null) // ~X2C
 530     {
 531         $this->_responsable = $responsable;
 532     }
 533     // -X2C
 534
 535     // +X2C Operation 301
 536     /**
 537      * Devuelve un array asociativo con los identificadores de los permisos
 538      *
 539      * @return array
 540      * @access public
 541      */
 542     function getIdPermisos() // ~X2C
 543     {
 544         return $this->_permisos;
 545     }
 546     // -X2C
 547
 548     // +X2C Operation 302
 549     /**
 550      * Setea los permisos de un sistema
 551      *
 552      * @param  int $permisos Array asociativo con los permisos
 553      *
 554      * @return void
 555      * @access public
 556      */
 557     function setPermisos($permisos = null) // ~X2C
 558     {
 559         $this->_permisos = $permisos;
 560     }
 561     // -X2C
 562
 563     // +X2C Operation 303
 564     /**
 565      * @return int
 566      * @access public
 567      */
 568     function getMaxIdSistema() // ~X2C
 569     {
 570         $sql = include 'Sistema/consultas.php';
 571         $dbh = $this->_db->prepare($sql['obtener_max_id_sistemas']);
 572         $res = $this->_db->execute($dbh);
 573         $re = $res->fetchrow(DB_FETCHMODE_ASSOC);
 574         $res->free();
 575         return $re['id_sistema'];
 576     }
 577     // -X2C
 578
 579     // +X2C Operation 304
 580     /**
 581      * Graba los datos en la Base de Datos
 582      *
 583      * @return void
 584      * @access protected
 585      */
 586     function _grabarDb() // ~X2C
 587     {
 588         $idSistema = $this->_db->nextId('sistema');
 589         $fecha_inicio         = $this->getFechaInicio();
 590         $fecha_fin            = $this->getFechaFin();
 591         $fecha_implementacion = $this->getFechaImplementacion();
 592         //USO SECUENCIAS Y AUTOEXECUTE
 593         //Grabo el sistema
 594         $datos = array(
 595                     'id_sistema'            => $idSistema,
 596                     'nombre_sistema'        => $this->getNombre(),
 597                     'desc_sistema'          => $this->getDescripcion(),
 598                     'fecha_inicio'          => $fecha_inicio         ? $fecha_inicio->format("%Y-%m-%d")         : null,
 599                     'fecha_fin'             => $fecha_fin            ? $fecha_fin->format("%Y-%m-%d")            : null,
 600                     'fecha_implementacion'  => $fecha_implementacion ? $fecha_implementacion->format("%Y-%m-%d") : null,
 601                     'contacto'              => $this->getContacto(),
 602                     'responsable'           => $this->getResponsable(),
 603                     'estado'                => 1
 604                 );
 605         $res = $this->_db->autoExecute('sistema', $datos, DB_AUTOQUERY_INSERT);
 606
 607         if (PEAR::isError($res)) {
 608             return $res;
 609         }
 610         //Grabo los permisos
 611         $res = $this->_grabarPermisosDb($idSistema);
 612         if (PEAR::isError($res)) {
 613             return $res;
 614         }
 615     }
 616     // -X2C
 617
 618     // +X2C Operation 305
 619     /**
 620      * Borra los datos de la base de datos
 621      *
 622      * @return void
 623      * @access protected
 624      */
 625     function _borrarDb() // ~X2C
 626     {
 627         $idSistema   = $this->getId();
 628         $responsable = $this->getResponsable();
 629         //Cambio el estado al sistema
 630         $datos = array( 'responsable' => $responsable,
 631                         'estado'      => 0
 632                 );
 633         $res = $this->_db->autoExecute('sistema', $datos, DB_AUTOQUERY_UPDATE, 'id_sistema = '.$idSistema);
 634         if (PEAR::isError($res)) {
 635             return $res;
 636         }
 637         //Borro los permisos que tiene asignado el sistema
 638         //Borro absolutamente todos los permisos que tiene asociado -> No hay vuelta a atras
 639         $res = $this->_borrarPermisosDb($idSistema);
 640         if (PEAR::isError($res)) {
 641             return $res;
 642         }
 643     }
 644     // -X2C
 645
 646     // +X2C Operation 306
 647     /**
 648      * Modifica los datos en base
 649      *
 650      * @return void
 651      * @access protected
 652      */
 653     function _modificarDb() // ~X2C
 654     {
 655         //Grabo las modificaciones al sistema
 656         $idSistema            = $this->getId();
 657         $fecha_inicio         = $this->getFechaInicio();
 658         $fecha_fin            = $this->getFechaFin();
 659         $fecha_implementacion = $this->getFechaImplementacion();
 660         //USO SECUENCIAS Y AUTOEXECUTE
 661         //Grabo el sistema
 662         $datos = array(
 663                     'nombre_sistema'        => $this->getNombre(),
 664                     'desc_sistema'          => $this->getDescripcion(),
 665                     'fecha_inicio'          => $fecha_inicio         ? $fecha_inicio->format("%Y-%m-%d")         : null,
 666                     'fecha_fin'             => $fecha_fin            ? $fecha_fin->format("%Y-%m-%d")            : null,
 667                     'fecha_implementacion'  => $fecha_implementacion ? $fecha_implementacion->format("%Y-%m-%d") : null,
 668                     'contacto'              => $this->getContacto(),
 669                     'responsable'           => $this->getResponsable(),
 670                 );
 671         $res = $this->_db->autoExecute('sistema', $datos, DB_AUTOQUERY_UPDATE, 'id_sistema = '.$idSistema);
 672         if (PEAR::isError($res)) {
 673             return $res;
 674         }
 675         //Borro los permisos que no tengan observaciones
 676         $res = $this->_borrarPermisosDb($idSistema, '');
 677         if (PEAR::isError($res)) {
 678             return $res;
 679         }
 680         //Grabo los permisos que selecciono
 681         $res = $this->_grabarPermisosDb($idSistema);
 682         if (PEAR::isError($res)) {
 683             return $res;
 684         }
 685     }
 686     // -X2C
 687
 688
 689     // +X2C Operation 308
 690     /**
 691      * Graba los permisos del sistema en perm_sist
 692      *
 693      * @param  int $idSistema Identificador del sistema
 694      *
 695      * @return void
 696      * @access protected
 697      */
 698     function _grabarPermisosDb($idSistema) // ~X2C
 699     {
 700         $datos = array ('id_permiso','id_sistema','responsable');
 701         $re = $this->_db->autoPrepare('perm_sist', $datos, DB_AUTOQUERY_INSERT);
 702         if (isset($this->_permisos)) {
 703             foreach ($this->_permisos as $permiso) {
 704                 $datos = array ($permiso['0'], $idSistema, $this->getResponsable());
 705                 $res = $this->_db->execute($re, $datos);
 706                 if (PEAR::isError($res)) {
 707                     return $res;
 708                 }
 709             }
 710         }
 711
 712     }
 713     // -X2C
 714
 715     // +X2C Operation 309
 716     /**
 717      * Borra los permisos que tenga asociado el sistema segun el criterio de observaciones
 718      *
 719      * @param  int $idSistema Identificador del sistema
 720      * @param  bool $observaciones Null u observacion de la asociacion a borrar
 721      * @param  int $idPermiso Identificador del permiso a borrar
 722      *
 723      * @return void
 724      * @access protected
 725      */
 726     function _borrarPermisosDb($idSistema, $observaciones = null, $idPermiso = null) // ~X2C
 727     {
 728         $sql = include 'Sistema/consultas.php';
 729         $datos[] = $idSistema;
 730         $tmp = $sql['borrar_permisos'];
 731         if (isset($observaciones)) {
 732             $tmp.= $sql['borrar_permisos2'];
 733             $datos[] = $observaciones;
 734         }
 735         if (isset($idPermiso)) {
 736             $tmp.= $sql['borrar_permisos3'];
 737             $datos[] = $idPermiso;
 738         }
 739         $dbh = $this->_db->prepare($tmp);
 740         $res = $this->_db->execute($dbh, $datos);
 741         if (PEAR::isError($res)) {
 742             return $res;
 743         }
 744     }
 745     // -X2C
 746
 747
 748     // +X2C Operation 312
 749     /**
 750      * Guarda en base las nuevas asociaciones que se van cargando y actualiza los datos del sistema.
 751      *
 752      * @param  int $idPermiso Identificador del Permiso
 753      * @param  string $observacion Observacion a agregar
 754      *
 755      * @return bool
 756      * @access public
 757      */
 758     function guardarAsociacion($idPermiso, $observacion = '') // ~X2C
 759     {
 760         $error = true;
 761         if (!$this->_existeAsociacion($idPermiso, $observacion)) {
 762             //Guardo la asociacion
 763             //Grabo el sistema
 764             $datos = array(
 765                         'id_permiso'    => $idPermiso,
 766                         'id_sistema'    => $this->getId(),
 767                         'observaciones' => $observacion,
 768                         'responsable'   => $this->getResponsable(),
 769                     );
 770             $res = $this->_db->autoExecute('perm_sist', $datos, DB_AUTOQUERY_INSERT);
 771             //Recargo los datos del sistema
 772             $this->_obtenerDatosDb();
 773             $error = false;
 774         }
 775         return $error;
 776     }
 777     // -X2C
 778
 779     // +X2C Operation 313
 780     /**
 781      * Elimina una asociacion de la base, y actualiza los datos del sistema.
 782      *
 783      * @param  int $idPermiso Identificador del permiso a borrar
 784      * @param  string $observacion Observacion de la asociacion a borrar (Puede ser vacia)
 785      *
 786      * @return bool
 787      * @access public
 788      */
 789     function eliminarAsociacion($idPermiso, $observacion = '') // ~X2C
 790     {
 791         $error = false;
 792         //Elimino la asociacion
 793         $this->_borrarPermisosDb($this->getId(), $observacion, $idPermiso);
 794         //Recargo los datos del sistema
 795         $this->_obtenerDatosDb();
 796         return $error;
 797     }
 798     // -X2C
 799
 800     // +X2C Operation 314
 801     /**
 802      * Actualiza los datos de la asociacion en la base de datos.
 803      *
 804      * @param  int $idPermiso Identificador del permiso
 805      * @param  int $idPermiso_ant Identificador del permiso anterior
 806      * @param  string $observacion Observacion a insertar
 807      * @param  string $obs_ant Observacion anterior
 808      *
 809      * @return bool
 810      * @access public
 811      */
 812     function modificarAsociacion($idPermiso, $idPermiso_ant, $observacion = '', $obs_ant = '') // ~X2C
 813     {
 814         $error = true;
 815         //Busco la nueva asociacion
 816         if (!$this->_existeAsociacion($idPermiso, $observacion)) {
 817             //Actualizo la asociacion
 818              $datos = array(
 819                         'id_permiso'    => $idPermiso,
 820                         'id_sistema'    => $this->getId(),
 821                         'observaciones' => $observacion,
 822                         'responsable'   => $this->getResponsable(),
 823                     );
 824             $this->_db->autoExecute('perm_sist',
 825                                     $datos,
 826                                     DB_AUTOQUERY_UPDATE,
 827                                     'id_sistema = '.$this->getId().' AND id_permiso = '.$idPermiso_ant.' AND observaciones =\''.$obs_ant.'\'');
 828
 829             //Recargo los datos del sistema
 830             $this->_obtenerDatosDb();
 831             $error = false;
 832         }
 833         return $error;
 834     }
 835     // -X2C
 836
 837     // +X2C Operation 315
 838     /**
 839      * Chequea si existe la asociacion
 840      *
 841      * @param  int $idPermiso Id del permiso a chequear
 842      * @param  string $observacion Observacion a chequear
 843      *
 844      * @return bool
 845      * @access protected
 846      */
 847     function _existeAsociacion($idPermiso, $observacion) // ~X2C
 848     {
 849         $sql = include 'Sistema/consultas.php'; //Incluyo las consultas de este objeto nada mas.
 850         $tmp = $sql['obtener_permisos'].$sql['obtener_permisos3'].$sql['obtener_permisos4'];
 851         $dbh = $this->_db->prepare($tmp);
 852         $tmp = array ($this->getId(),$idPermiso,$observacion);
 853         $res = $this->_db->execute($dbh,$tmp);
 854         $re  = $res->fetchRow();
 855
 856         if (is_null($re)) {
 857             return false;
 858         }
 859         else {
 860             return true;
 861         }
 862     }
 863     // -X2C
 864
 865     // +X2C Operation 341
 866     /**
 867      * Devuelve el array de sistemas
 868      *
 869      * @param  SAMURAI_DB &$db Base de Datos
 870      *
 871      * @return array(Sistema)
 872      * @access public
 873      * @static
 874      */
 875     function getSistemas(&$db) // ~X2C
 876     {
 877         $rta = array ();
 878         foreach (SAMURAI_Sistema::_getIdSistemas($db) as $id) {
 879             $tmp = new SAMURAI_Sistema($db,$id);
 880             array_push($rta, $tmp);
 881         }
 882         return $rta;
 883     }
 884     // -X2C
 885
 886     // +X2C Operation 342
 887     /**
 888      * Devuleve un array con los identificadores de todos los sistemas.
 889      *
 890      * @param  SAMURAI_DB &$db Base de Datos
 891      *
 892      * @return array(int)
 893      * @access protected
 894      * @static
 895      */
 896     function _getIdSistemas(&$db) // ~X2C
 897     {
 898         //OBTENGO LOS ID DE LA BASE
 899         $rta = array();
 900         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 901         $dbh = $db->prepare($sql['obtener_datos_sistema'].$sql['obtener_datos_sistema3']);
 902         $res = $db->execute($dbh);
 903         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 904             array_push($rta,$re['id_sistema']);
 905         }
 906         $res->free();
 907         return $rta;
 908     }
 909     // -X2C
 910
 911     // +X2C Operation 343
 912     /**
 913      * Devuelve un array asociativo en donde la clave es el identificador y el valor es el nombre del sistema
 914      *
 915      * @param  SAMURAI_DB &$db Base de Datos
 916      *
 917      * @return array()
 918      * @access public
 919      * @static
 920      */
 921     function getArraySistemas(&$db) // ~X2C
 922     {
 923         $rta = array ();
 924         foreach (SAMURAI_Sistema::getSistemas($db) as $sistema) {
 925             $rta[$sistema->getId()] = $sistema->getNombre();
 926         }
 927         return $rta;
 928     }
 929     // -X2C
 930
 931 } // -X2C Class :SAMURAI_Sistema
 932
 933 ?>