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