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