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