lib/SAMURAI/Usuario.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 'Perfil.php';
  29 require_once 'MECON/Usuario.php';
  30
  31
  32 // +X2C Class 207 :SAMURAI_Usuario
  33 /**
  34  * Clase para el manejo de los usuarios.
  35 @see \ref page_samurai_html_usuario
  36  *
  37  * @access public
  38  */
  39 class SAMURAI_Usuario {
  40     /**
  41      * Login del usuario en intranet.
  42      *
  43      * @var    string $login
  44      * @access protected
  45      */
  46     var $_login;
  47
  48     /**
  49      * Numero de documento del usuario
  50      *
  51      * @var    int $nrodoc
  52      * @access protected
  53      */
  54     var $_nrodoc;
  55
  56     /**
  57      * Nombre del usuario
  58      *
  59      * @var    string $nombre
  60      * @access protected
  61      */
  62     var $_nombre;
  63
  64     /**
  65      * Objeto Samurai_DB
  66      *
  67      * @var    SAMURAI_DB $db
  68      * @access protected
  69      */
  70     var $_db;
  71
  72     /**
  73      * Array con los identificadores de los perfiles asociados a un usuario
  74      *
  75      * @var    array(int) $perfiles
  76      * @access protected
  77      */
  78     var $_perfiles;
  79
  80     /**
  81      * Identificador del sistema en el cual se esta trabajando.
  82      *
  83      * @var    int $idSistema
  84      * @access protected
  85      */
  86     var $_idSistema;
  87
  88     /**
  89      * Gets Login.
  90      *
  91      * @return string
  92      * @access public
  93      */
  94     function getLogin()
  95     {
  96         return $this->_login;
  97     }
  98     /**
  99      * Sets Login.
 100      *
 101      * @param  string $login Login.
 102      *
 103      * @return void
 104      * @access public
 105      */
 106     function setLogin($login)
 107     {
 108         $this->_login = $login;
 109     }
 110
 111     /**
 112      * Gets Nrodoc.
 113      *
 114      * @return int
 115      * @access public
 116      */
 117     function getNrodoc()
 118     {
 119         return $this->_nrodoc;
 120     }
 121     /**
 122      * Sets Nrodoc.
 123      *
 124      * @param  int $nrodoc Nrodoc.
 125      *
 126      * @return void
 127      * @access public
 128      */
 129     function setNrodoc($nrodoc)
 130     {
 131         $this->_nrodoc = $nrodoc;
 132     }
 133
 134     /**
 135      * Gets Nombre.
 136      *
 137      * @return string
 138      * @access public
 139      */
 140     function getNombre()
 141     {
 142         return $this->_nombre;
 143     }
 144     /**
 145      * Sets Nombre.
 146      *
 147      * @param  string $nombre Nombre.
 148      *
 149      * @return void
 150      * @access public
 151      */
 152     function setNombre($nombre)
 153     {
 154         $this->_nombre = $nombre;
 155     }
 156
 157     /**
 158      * Gets Perfiles.
 159      *
 160      * @return array(int)
 161      * @access public
 162      */
 163     function getPerfiles()
 164     {
 165         return $this->_perfiles;
 166     }
 167     /**
 168      * Sets Perfiles.
 169      *
 170      * @param  array(int) $perfiles Perfiles.
 171      *
 172      * @return void
 173      * @access public
 174      */
 175     function setPerfiles($perfiles)
 176     {
 177         $this->_perfiles = $perfiles;
 178     }
 179
 180     // ~X2C
 181
 182     // +X2C Operation 216
 183     /**
 184      * Constructor.Recibe como parametro opcional el login del usuario. y busca en la base la informacion referida a el.
 185      *
 186      * @param  SAMURAI_DB &$db Objeto conexion.
 187      * @param  string $login Login del usuario
 188      * @param  int $idSistema Identificador del sistema en el cual se esta trabajando
 189      *
 190      * @return void
 191      * @access public
 192      */
 193     function SAMURAI_Usuario(&$db, $login = null, $idSistema = null) // ~X2C
 194     {
 195         $this->_db = $db;
 196         $this->setLogin($login);
 197         $this->_idSistema = $idSistema;
 198         if (!is_null($login)) {
 199             $tmp =& new MECON_Usuario(null, $login);
 200             $this->setNrodoc($tmp->getDni());
 201             $this->setNombre($tmp->getNombre());
 202             $this->_obtenerDatosDb();
 203         }
 204     }
 205     // -X2C
 206
 207     // +X2C Operation 365
 208     /**
 209      * Devuleve un array con los login's de los usuarios asociados al sistema
 210      *
 211      * @param  SAMURAI_DB &$db Base de Datos
 212      * @param  int $id_sistema Identificador del sistema
 213      *
 214      * @return array(string)
 215      * @access protected
 216      * @static
 217      */
 218     function _getLoginUsuarios(&$db, $id_sistema = null) // ~X2C
 219     {
 220         //OBTENGO LOS LOGIN DE LA BASE
 221         $consulta='';
 222         $rta = array();
 223         $tmp = array();
 224         $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
 225         if ($id_sistema) {
 226             $consulta.= $sql['obtener_datos_usuario2'];
 227             $tmp[] = $id_sistema;
 228         }
 229         else {
 230             $consulta = $sql['obtener_datos_usuario'];
 231         }
 232         $consulta.= $sql['obtener_datos_usuario4'];
 233         $dbh = $db->prepare($consulta);
 234         $res = $db->execute($dbh, $tmp);
 235         while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
 236             array_push($rta,$re['login']);
 237         }
 238         $res->free();
 239         return $rta;
 240     }
 241     // -X2C
 242
 243     // +X2C Operation 366
 244     /**
 245      * Devuelve un array asociativo en donde la clave es el login y el valor es el nombre del usuario
 246      *
 247      * @param  SAMURAI_DB &$db Base de Datos
 248      * @param  int $id_sistema Identificador del sistema
 249      *
 250      * @return array()
 251      * @access public
 252      * @static
 253      */
 254     function getArrayUsuarios(&$db, $id_sistema = null) // ~X2C
 255     {
 256         //FORECHEO LO QUE ME DEVUELVA GET USUARIOS
 257         $rta = array ();
 258         foreach (SAMURAI_Usuario::getUsuarios($db, $id_sistema) as $Usuario) {
 259             $rta[$Usuario->getLogin()] = $Usuario->getNombre();
 260         }
 261         return $rta;
 262     }
 263     // -X2C
 264
 265     // +X2C Operation 367
 266     /**
 267      * Devuelve el array de usuarios
 268      *
 269      * @param  SAMURAI_DB &$db Base de Datos
 270      * @param  int $id_sistema Identificador del sistema
 271      *
 272      * @return array(Permiso)
 273      * @access public
 274      * @static
 275      */
 276     function getUsuarios(&$db, $id_sistema = null) // ~X2C
 277     {
 278         $rta = array ();
 279         foreach (SAMURAI_Usuario::_getLoginUsuarios($db, $id_sistema) as $login) {
 280             $tmp = new SAMURAI_Usuario($db, $login, $id_sistema);
 281             array_push($rta, $tmp);
 282         }
 283         return $rta;
 284     }
 285     // -X2C
 286
 287     // +X2C Operation 368
 288     /**
 289      * Obtiene de la base de datos la informacion del usuario
 290      *
 291      * @return void
 292      * @access protected
 293      */
 294     function _obtenerDatosDb() // ~X2C
 295     {
 296         $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
 297
 298         $tmp = $sql['obtener_perfiles_usuario'];
 299         $dbh = $this->_db->prepare($tmp);
 300         $res = $this->_db->execute($dbh,array($this->getLogin(),
 301                     $this->_idSistema));
 302         $rta = array();
 303
 304         while ($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
 305             $tmp = new SAMURAI_Perfil($this->_db, $re['id_perfil'],
 306                     $this->_idSistema);
 307             $rta[] = $tmp->getId();
 308         }
 309         $this->setPerfiles($rta);
 310     }
 311     // -X2C
 312
 313     // +X2C Operation 370
 314     /**
 315      * Modifica la base de datos segun accion
 316      *
 317      * @param  string $accion Indica la accion a realizar
 318      *
 319      * @return mixed
 320      * @access public
 321      */
 322     function guardarDatos($accion = grabar) // ~X2C
 323     {
 324         $accion = strtolower($accion);
 325         switch ($accion)  {
 326             case 'grabar':
 327                 $res = $this->_grabarDb();
 328                 break;
 329             case 'modificar':
 330                 $res = $this->_modificarDb();
 331                 break;
 332             case 'eliminar':
 333                 $res = $this->_borrarDb();
 334                 break;
 335         }
 336         return $res;
 337     }
 338     // -X2C
 339
 340     // +X2C Operation 371
 341     /**
 342      * Graba en base la relacion
 343      *
 344      * @return mixed
 345      * @access protected
 346      */
 347     function _grabarDb() // ~X2C
 348     {
 349         $datos = array ('login', 'id_perfil', 'id_sistema', 'responsable');
 350         $re = $this->_db->autoPrepare('samurai.perfil_sist_usuario', $datos, DB_AUTOQUERY_INSERT);
 351         foreach ($this->getPerfiles() as $perfil) {
 352             $datos = array ($this->getLogin(),
 353                             $perfil,
 354                             $this->_idSistema,
 355                             $_SESSION['usuario']);
 356             $res = $this->_db->execute($re, $datos);
 357             if (PEAR::isError($res)) {
 358                 return $res;
 359             }
 360         }
 361     }
 362     // -X2C
 363
 364     // +X2C Operation 372
 365     /**
 366      * Borra de la base la relacion
 367      *
 368      * @return mixed
 369      * @access protected
 370      */
 371     function _borrarDb() // ~X2C
 372     {
 373         $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
 374         $tmp = $sql['borrar'];
 375         $dbh = $this->_db->prepare($tmp);
 376         $tmp = array ($this->getLogin(), $this->_idSistema);
 377         return $this->_db->execute($dbh,$tmp);
 378     }
 379     // -X2C
 380
 381     // +X2C Operation 373
 382     /**
 383      * Actualiza los datos de la relacion
 384      *
 385      * @return mixed
 386      * @access protected
 387      */
 388     function _modificarDb() // ~X2C
 389     {
 390         $this->_borrarDb();
 391         $this->_grabarDb();
 392     }
 393     // -X2C
 394
 395     // +X2C Operation 374
 396     /**
 397      * Verifica si el login actual es valido
 398      *
 399      * @return mixed
 400      * @access public
 401      */
 402     function verificarLogin() // ~X2C
 403     {
 404         $usu = new MECON_Usuario();
 405         $tmp = $usu->verificarLogin($this->getLogin());
 406         if ($tmp) {
 407             if (PEAR::isError($tmp)) {
 408                 return $tmp;
 409             }
 410             else {
 411                 return true;
 412             }
 413         }
 414         else {
 415             return new PEAR_Error('Usuario no reconocido.<br>Recuerde que &eacute;ste debe haberse logueado previamente a Intranet');
 416         }
 417     }
 418     // -X2C
 419
 420     // +X2C Operation 375
 421     /**
 422      * Verifica si el login actual ya esta asociado en base.
 423      *
 424      * @return mixed
 425      * @access public
 426      */
 427     function verificarAsociacionExistente() // ~X2C
 428     {
 429         $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
 430         $tmp = $sql['verificar_login2'];
 431         $dbh = $this->_db->prepare($tmp);
 432         $res = $this->_db->execute($dbh,array($this->getLogin(),
 433                     $this->_idSistema));
 434         $re  = $res->fetchRow(DB_FETCHMODE_ASSOC);
 435         if ($re['login']) {
 436             return new PEAR_Error('El usuario seleccionado ya esta cargado. Modifique sus opciones.');
 437         }
 438         return 1;
 439     }
 440     // -X2C
 441
 442     // +X2C Operation 386
 443     /**
 444      * Metodo estatico que permite asociar un usuario con un perfil en un sistema determinado.
 445      *
 446      * @param  DB &$db Conexion a la base de datos
 447      * @param  string $login Login del usuario que se quiere asociar
 448      * @param  int $id_perfil Identificador del perfil que se quiere asociar
 449      * @param  int $id_sistema identificador del sistema en el que se esta haciendo la asociacion
 450      * @param  int $responsable Login del usuario que esta haciendo los cambios
 451      *
 452      * @return mixed
 453      * @access public
 454      * @static
 455      */
 456     function asociarPerfil(&$db, $login, $id_perfil, $id_sistema, $responsable) // ~X2C
 457     {
 458         $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
 459
 460         $usu = new MECON_Usuario();
 461         $tmp = $usu->verificarLogin($login);
 462         if ($tmp) {
 463             if (PEAR::isError($tmp)) {
 464                 return $tmp;
 465             }
 466         }
 467         else {
 468             return new PEAR_Error('Usuario no reconocido.<br>Recuerde que &eacute;ste debe haberse logueado previamente a Intranet');
 469         }
 470
 471         //Asocio el perfil con el usuario en perfil_sist_usuario
 472         $datos = array ('login'       => $login,
 473                         'id_perfil'   => $id_perfil,
 474                         'id_sistema'  => $id_sistema,
 475                         'responsable' => $responsable);
 476
 477         $res = $db->autoExecute('samurai.perfil_sist_usuario', $datos, DB_AUTOQUERY_INSERT);
 478         if (PEAR::isError($res)) {
 479             return $res;
 480         }
 481
 482         return 1;
 483     }
 484     // -X2C
 485
 486     // +X2C Operation 396
 487     /**
 488      * Devuelve la informacion completa del usuario. Sistemas a los que esta asignado, perfiles que tiene dentro de cada sistema y permisos.
 489      *
 490      * @return mixed
 491      * @access public
 492      */
 493     function informacionGeneral() // ~X2C
 494     {
 495         $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
 496         $tmp = $sql['obtener_informacion'];
 497         $dbh = $this->_db->prepare($tmp);
 498         $res = $this->_db->execute($dbh,array($this->getLogin()));
 499
 500         if (PEAR::isError($res)) {
 501             return $res;
 502         }
 503
 504         $rta = array();
 505
 506         while ($re = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
 507             $rta[$re['id_sistema']]['nombre_sistema'] = $re['nombre_sistema'];
 508             $rta[$re['id_sistema']]['perfiles'][$re['id_perfil']]['desc_perfil'] =
 509                 $re['desc_perfil'];
 510
 511             $rta[$re['id_sistema']]['perfiles'][$re['id_perfil']]['permisos'][$re['id_permiso']]
 512                 [$re['observaciones']]['desc_permiso'] = $re['desc_permiso'];
 513
 514             $rta[$re['id_sistema']]['perfiles'][$re['id_perfil']]['permisos'][$re['id_permiso']]
 515                 [$re['observaciones']]['observaciones'] = $re['observaciones'];
 516         }
 517
 518         return $rta;
 519     }
 520     // -X2C
 521
 522     // +X2C Operation 398
 523     /**
 524      * Funcion que obtiene la lista de usuarios que tienen al menos un permiso en la intranet.
 525      *
 526      * @param  DB &$db Conexion a la base de datos
 527      * @param  string $login Parte del login a filtrar
 528      *
 529      * @return mixed
 530      * @access public
 531      * @static
 532      */
 533     function filtrarUsuarios(&$db, $login) // ~X2C
 534     {
 535         $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
 536         $sql = str_replace ('##?##', $login, $sql['obtener_datos_compartido']);
 537         $db->setFetchMode(DB_FETCHMODE_ASSOC);
 538         return $db->query($sql);
 539     }
 540     // -X2C
 541
 542 } // -X2C Class :SAMURAI_Usuario
 543 ?>