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