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