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         $this->_id = $idSistema;
 617     }
 618     // -X2C
 619
 620     // +X2C Operation 305
 621     /**
 622      * Borra los datos de la base de datos
 623      *
 624      * @return void
 625      * @access protected
 626      */
 627     function _borrarDb() // ~X2C
 628     {
 629         $idSistema   = $this->getId();
 630         $responsable = $this->getResponsable();
 631         //Cambio el estado al sistema
 632         $datos = array( 'responsable' => $responsable,
 633                         'estado'      => 0
 634                 );
 635         $res = $this->_db->autoExecute('sistema', $datos, DB_AUTOQUERY_UPDATE, 'id_sistema = '.$idSistema);
 636         if (PEAR::isError($res)) {
 637             return $res;
 638         }
 639
 640         if ($idSistema == $_SESSION['samurai']['id_sistema']){
 641             $_SESSION['samurai']['id_sistema'] = '';
 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, $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 = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 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         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             return null;
 773         }
 774         else {
 775             return new PEAR_Error('La Asociacion ya existe.');
 776         }
 777     }
 778     // -X2C
 779
 780     // +X2C Operation 313
 781     /**
 782      * Elimina una asociacion de la base, y actualiza los datos del sistema.
 783      *
 784      * @param  int $idPermiso Identificador del permiso a borrar
 785      * @param  string $observacion Observacion de la asociacion a borrar (Puede ser vacia)
 786      *
 787      * @return bool
 788      * @access public
 789      */
 790     function eliminarAsociacion($idPermiso, $observacion = '') // ~X2C
 791     {
 792         //TODO Arreglar el asco este
 793         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 794         $res = '';
 795         //Obtengo los id de los perfiles del permiso en el sistema
 796         $tmp = $sql['ea_obt_idperfil'];
 797         $dbh = $this->_db->prepare($tmp);
 798         $res = $this->_db->execute($dbh, array ($idPermiso, $observacion, $this->getId()));
 799         if (PEAR::isError($res)) {
 800             return $res;
 801         }
 802         $i = 0;
 803         $tmp = '';
 804         while ($re = $res->fetchRow(DB_FETCHMODE_ORDERED)) {
 805             $tmp[] = $re['0'];
 806             $i++;
 807         }
 808         $PERFILES = $tmp;
 809         //Borro el permiso de los perfiles del sistema
 810         $tmp = $sql['ea_del_perm_perfil_sist'];
 811         $dbh = $this->_db->prepare($tmp);
 812         $res = $this->_db->execute($dbh, array ($idPermiso, $observacion, $this->getId()));
 813         if (PEAR::isError($res)) {
 814             return $res;
 815         }
 816         //Verifico si era el unico permiso de cada uno de los perfiles en los que estaba asignado
 817         if (@$PERFILES) {
 818             foreach ($PERFILES as $perfil) {
 819                 //Cuento
 820                 $tmp = $sql['ea_obt_cuenta_perfil'];
 821                 $dbh = $this->_db->prepare($tmp);
 822                 $res = $this->_db->execute($dbh, array ($perfil, $this->getId()));
 823                 if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && $re['cuenta'] == 0) {
 824                     //Borro perfil_sist
 825                     $tmp = $sql['ea_del_perfil_sist'];
 826                     $dbh = $this->_db->prepare($tmp);
 827                     $res = $this->_db->execute($dbh, array ($perfil, $this->getId()));
 828                     if (PEAR::isError($res)) {
 829                         return $res;
 830                     }
 831                     //Borro perfil_sist_usuario
 832                     $tmp = $sql['ea_del_perfil_sist_usuario'];
 833                     $dbh = $this->_db->prepare($tmp);
 834                     $res = $this->_db->execute($dbh, array ($perfil, $this->getId()));
 835                     if (PEAR::isError($res)) {
 836                         return $res;
 837                     }
 838                     //Verifico si hay otro sistema usando este perfil
 839                     $tmp = $sql['ea_obt_cuenta_perfil_sist'];
 840                     $dbh = $this->_db->prepare($tmp);
 841                     $res = $this->_db->execute($dbh, array ($perfil));
 842                     if (($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) && $re['cuenta'] == 0){
 843                         $tmp = $sql['ea_del_perfil'];
 844                         $dbh = $this->_db->prepare($tmp);
 845                         $res = $this->_db->execute($dbh, array ($perfil));
 846                         if (PEAR::isError($res)) {
 847                             return $res;
 848                         }
 849                     }
 850                 }
 851             }
 852         }
 853         //Borro la asociacion perm_sist
 854         $res = $this->_borrarPermisosDb($this->getId(), $observacion, $idPermiso);
 855         if (PEAR::isError($res)) {
 856             return $res;
 857         }
 858         //Recargo los datos del sistema
 859         $this->_obtenerDatosDb();
 860     }
 861     // -X2C
 862
 863     // +X2C Operation 314
 864     /**
 865      * Actualiza los datos de la asociacion en la base de datos.
 866      *
 867      * @param  int $idPermiso Identificador del permiso
 868      * @param  string $observacion Observacion a insertar
 869      * @param  string $obs_ant Observacion anterior
 870      *
 871      * @return bool
 872      * @access public
 873      */
 874     function modificarAsociacion($idPermiso, $observacion = '', $obs_ant = '') // ~X2C
 875     {
 876         //Busco la nueva asociacion
 877         if (!$this->_existeAsociacion($idPermiso, $observacion)) {
 878             //Actualizo la asociacion
 879              $datos = array(
 880                         'id_permiso'    => $idPermiso,
 881                         'id_sistema'    => $this->getId(),
 882                         'observaciones' => $observacion,
 883                         'responsable'   => $this->getResponsable(),
 884                     );
 885             $this->_db->autoExecute('perm_sist',
 886                                     $datos,
 887                                     DB_AUTOQUERY_UPDATE,
 888                                     'id_sistema = '.$this->getId().' AND id_permiso = '.$idPermiso.' AND observaciones =\''.$obs_ant.'\'');
 889
 890             //Recargo los datos del sistema
 891             $this->_obtenerDatosDb();
 892             return null;
 893         }
 894         else {
 895             return new PEAR_Error('La Asociacion ya existe.');
 896         }
 897     }
 898     // -X2C
 899
 900     // +X2C Operation 315
 901     /**
 902      * Chequea si existe la asociacion
 903      *
 904      * @param  int $idPermiso Id del permiso a chequear
 905      * @param  string $observacion Observacion a chequear
 906      *
 907      * @return bool
 908      * @access protected
 909      */
 910     function _existeAsociacion($idPermiso, $observacion) // ~X2C
 911     {
 912         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 913         $tmp = $sql['obtener_permisos'].$sql['obtener_permisos3'].$sql['obtener_permisos4'];
 914         $dbh = $this->_db->prepare($tmp);
 915         $tmp = array ($this->getId(),$idPermiso,$observacion);
 916         $res = $this->_db->execute($dbh,$tmp);
 917         $re  = $res->fetchRow();
 918
 919         if (is_null($re)) {
 920             return false;
 921         }
 922         else {
 923             return true;
 924         }
 925     }
 926     // -X2C
 927
 928     // +X2C Operation 341
 929     /**
 930      * Devuelve el array de sistemas
 931      *
 932      * @param  SAMURAI_DB &$db Base de Datos
 933      *
 934      * @return array(Sistema)
 935      * @access public
 936      * @static
 937      */
 938     function getSistemas(&$db) // ~X2C
 939     {
 940         $rta = array ();
 941         foreach (SAMURAI_Sistema::_getIdSistemas($db) as $id) {
 942             $tmp = new SAMURAI_Sistema($db,$id);
 943             array_push($rta, $tmp);
 944         }
 945         return $rta;
 946     }
 947     // -X2C
 948
 949     // +X2C Operation 342
 950     /**
 951      * Devuleve un array con los identificadores de todos los sistemas.
 952      *
 953      * @param  SAMURAI_DB &$db Base de Datos
 954      *
 955      * @return array(int)
 956      * @access protected
 957      * @static
 958      */
 959     function _getIdSistemas(&$db) // ~X2C
 960     {
 961         //OBTENGO LOS ID DE LA BASE
 962         $rta = array();
 963         $sql = parse_ini_file(dirname(__FILE__) . '/Sistema/consultas.ini', true);
 964         $dbh = $db->prepare($sql['obtener_datos_sistema'].$sql['obtener_datos_sistema3'].$sql['obtener_datos_sistema4']);
 965         $res = $db->execute($dbh);
 966         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 967             array_push($rta,$re['id_sistema']);
 968         }
 969         $res->free();
 970         return $rta;
 971     }
 972     // -X2C
 973
 974     // +X2C Operation 343
 975     /**
 976      * Devuelve un array asociativo en donde la clave es el identificador y el valor es el nombre del sistema
 977      *
 978      * @param  SAMURAI_DB &$db Base de Datos
 979      *
 980      * @return array()
 981      * @access public
 982      * @static
 983      */
 984     function getArraySistemas(&$db) // ~X2C
 985     {
 986         $rta = array ();
 987         foreach (SAMURAI_Sistema::getSistemas($db) as $sistema) {
 988             $rta[$sistema->getId()] = $sistema->getNombre();
 989         }
 990         return $rta;
 991     }
 992     // -X2C
 993
 994 } // -X2C Class :SAMURAI_Sistema
 995
 996 ?>