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