<?php
// vim: set expandtab tabstop=4 softtabstop=4 shiftwidth=4:
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license,      |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Created: Tue May 27 11:20:04 2003
// | Author:  Martin Marrese - Myrna Degano <mmarre@mecon.gov.ar - mdegan@mecon.gov.ar>
// +----------------------------------------------------------------------+
//
// $Id$
// $Author$
// $URL$
// $Date$
// $Rev$
//

require_once 'PEAR.php';
require_once 'Perfil.php';
require_once 'MECON/Usuario.php';


// +X2C Class 207 :SAMURAI_Usuario
/**
 * Clase para el manejo de los usuarios.
@see \ref page_samurai_html_usuario
 *
 * @access public
 */
class SAMURAI_Usuario {
    /**
     * Login del usuario en intranet.
     *
     * @var    string $login
     * @access protected
     */
    var $_login;

    /**
     * Numero de documento del usuario
     *
     * @var    int $nrodoc
     * @access protected
     */
    var $_nrodoc;

    /**
     * Nombre del usuario
     *
     * @var    string $nombre
     * @access protected
     */
    var $_nombre;

    /**
     * Objeto Samurai_DB
     *
     * @var    SAMURAI_DB $db
     * @access protected
     */
    var $_db;

    /**
     * Array con los identificadores de los perfiles asociados a un usuario
     *
     * @var    array(int) $perfiles
     * @access protected
     */
    var $_perfiles;

    /**
     * Identificador del sistema en el cual se esta trabajando.
     *
     * @var    int $idSistema
     * @access protected
     */
    var $_idSistema;

    /**
     * Gets Login.
     *
     * @return string
     * @access public
     */
    function getLogin()
    {
        return $this->_login;
    }
    /**
     * Sets Login.
     *
     * @param  string $login Login.
     *
     * @return void
     * @access public
     */
    function setLogin($login)
    {
        $this->_login = $login;
    }

    /**
     * Gets Nrodoc.
     *
     * @return int
     * @access public
     */
    function getNrodoc()
    {
        return $this->_nrodoc;
    }
    /**
     * Sets Nrodoc.
     *
     * @param  int $nrodoc Nrodoc.
     *
     * @return void
     * @access public
     */
    function setNrodoc($nrodoc)
    {
        $this->_nrodoc = $nrodoc;
    }

    /**
     * Gets Nombre.
     *
     * @return string
     * @access public
     */
    function getNombre()
    {
        return $this->_nombre;
    }
    /**
     * Sets Nombre.
     *
     * @param  string $nombre Nombre.
     *
     * @return void
     * @access public
     */
    function setNombre($nombre)
    {
        $this->_nombre = $nombre;
    }

    /**
     * Gets Perfiles.
     *
     * @return array(int)
     * @access public
     */
    function getPerfiles()
    {
        return $this->_perfiles;
    }
    /**
     * Sets Perfiles.
     *
     * @param  array(int) $perfiles Perfiles.
     *
     * @return void
     * @access public
     */
    function setPerfiles($perfiles)
    {
        $this->_perfiles = $perfiles;
    }

    // ~X2C

    // +X2C Operation 216
    /**
     * Constructor.Recibe como parametro opcional el login del usuario. y busca en la base la informacion referida a el.
     *
     * @param  SAMURAI_DB &$db Objeto conexion.
     * @param  string $login Login del usuario
     * @param  int $idSistema Identificador del sistema en el cual se esta trabajando
     *
     * @return void
     * @access public
     */
    function SAMURAI_Usuario(&$db, $login = null, $idSistema = null) // ~X2C
    {
        $this->_db = $db; 
        $this->setLogin($login);
        $this->_idSistema = $idSistema;
        if (!is_null($login)) {
            $tmp =& new MECON_Usuario($db, null, $login);
            $this->setNrodoc($tmp->getDni());
            $this->setNombre($tmp->getNombre());
            $this->_obtenerDatosDb();
        }
    }
    // -X2C

    // +X2C Operation 365
    /**
     * Devuleve un array con los login's de los usuarios asociados al sistema
     *
     * @param  SAMURAI_DB &$db Base de Datos
     * @param  int $id_sistema Identificador del sistema
     *
     * @return array(string)
     * @access protected
     * @static
     */
    function _getLoginUsuarios(&$db, $id_sistema = null) // ~X2C
    {
        //OBTENGO LOS LOGIN DE LA BASE
        $consulta='';
        $rta = array();
        $tmp = array();
        $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
        if ($id_sistema) {
            $consulta.= $sql['obtener_datos_usuario2'];
            $tmp[] = $id_sistema;
        }
        else {
            $consulta = $sql['obtener_datos_usuario'];
        }
        $consulta.= $sql['obtener_datos_usuario4'];
        $dbh = $db->prepare($consulta);
        $res = $db->execute($dbh, $tmp);
        while ($re = $res->fetchrow(DB_FETCHMODE_ASSOC)) {
            array_push($rta,$re['login']);
        }        
        $res->free();
        return $rta;
    }
    // -X2C

    // +X2C Operation 366
    /**
     * Devuelve un array asociativo en donde la clave es el login y el valor es el nombre del usuario
     *
     * @param  SAMURAI_DB &$db Base de Datos
     * @param  int $id_sistema Identificador del sistema
     *
     * @return array()
     * @access public
     * @static
     */
    function getArrayUsuarios(&$db, $id_sistema = null) // ~X2C
    {
        //FORECHEO LO QUE ME DEVUELVA GET USUARIOS
        $rta = array ();
        foreach (SAMURAI_Usuario::getUsuarios($db, $id_sistema) as $Usuario) {
            $rta[$Usuario->getLogin()] = $Usuario->getNombre();
        }
        return $rta;
    }
    // -X2C

    // +X2C Operation 367
    /**
     * Devuelve el array de usuarios
     *
     * @param  SAMURAI_DB &$db Base de Datos
     * @param  int $id_sistema Identificador del sistema
     *
     * @return array(Permiso)
     * @access public
     * @static
     */
    function getUsuarios(&$db, $id_sistema = null) // ~X2C
    {
        $rta = array ();
        foreach (SAMURAI_Usuario::_getLoginUsuarios($db, $id_sistema) as $login) {
            $tmp = new SAMURAI_Usuario($db, $login, $id_sistema);
            array_push($rta, $tmp);
        }
        return $rta;
    }
    // -X2C

    // +X2C Operation 368
    /**
     * Obtiene de la base de datos la informacion del usuario
     *
     * @return void
     * @access protected
     */
    function _obtenerDatosDb() // ~X2C
    {
        $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
        
        $tmp = $sql['obtener_perfiles_usuario'];
        $dbh = $this->_db->prepare($tmp);
        $res = $this->_db->execute($dbh,array($this->getLogin(),
                    $this->_idSistema));
        $rta = array();

        while ($re  = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
            $tmp = new SAMURAI_Perfil($this->_db, $re['id_perfil'],
                    $this->_idSistema);
            $rta[] = $tmp->getId();
        }
        $this->setPerfiles($rta);
    }
    // -X2C

    // +X2C Operation 370
    /**
     * Modifica la base de datos segun accion
     *
     * @param  string $accion Indica la accion a realizar
     *
     * @return mixed
     * @access public
     */
    function guardarDatos($accion = 'grabar') // ~X2C
    {
        $accion = strtolower($accion); 
        switch ($accion)  {   
            case 'grabar':    
                $res = $this->_grabarDb();            
                break;        
            case 'modificar': 
                $res = $this->_modificarDb();         
                break;        
            case 'eliminar':  
                $res = $this->_borrarDb();            
                break;        
        }
        return $res;
    }
    // -X2C

    // +X2C Operation 371
    /**
     * Graba en base la relacion
     *
     * @return mixed
     * @access protected
     */
    function _grabarDb() // ~X2C
    {   
        $datos = array ('login', 'id_perfil', 'id_sistema', 'responsable');
        $re = $this->_db->autoPrepare('samurai.perfil_sist_usuario', $datos, DB_AUTOQUERY_INSERT);
        foreach ($this->getPerfiles() as $perfil) {
            $datos = array ($this->getLogin(),
                            $perfil,
                            $this->_idSistema, 
                            $_SESSION['usuario']);
            $res = $this->_db->execute($re, $datos);
            if (PEAR::isError($res)) {
                return $res;
            }
        }
    }
    // -X2C

    // +X2C Operation 372
    /**
     * Borra de la base la relacion
     *
     * @return mixed
     * @access protected
     */
    function _borrarDb() // ~X2C
    {
        $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
        $tmp = $sql['borrar'];
        $dbh = $this->_db->prepare($tmp);
        $tmp = array ($this->getLogin(), $this->_idSistema);
        return $this->_db->execute($dbh,$tmp);        
    }
    // -X2C

    // +X2C Operation 373
    /**
     * Actualiza los datos de la relacion
     *
     * @return mixed
     * @access protected
     */
    function _modificarDb() // ~X2C
    {
        $this->_borrarDb();
        $this->_grabarDb();
    }
    // -X2C

    // +X2C Operation 374
    /**
     * Verifica si el login actual es valido
     *
     * @return mixed
     * @access public
     */
    function verificarLogin() // ~X2C
    {
        $usu = new MECON_Usuario($this->_db);
        $tmp = $usu->verificarLogin($this->getLogin()); 
        if ($tmp) {
            if (PEAR::isError($tmp)) {
                return $tmp;
            }
            else {
                return true;
            }
        }
        else {
            return new PEAR_Error('Usuario no reconocido.<br>Recuerde que &eacute;ste debe haberse logueado previamente a Intranet');
        }
    }
    // -X2C

    // +X2C Operation 375
    /**
     * Verifica si el login actual ya esta asociado en base.
     *
     * @return mixed
     * @access public
     */
    function verificarAsociacionExistente() // ~X2C
    {
        $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
        $tmp = $sql['verificar_login2'];
        $dbh = $this->_db->prepare($tmp);
        $res = $this->_db->execute($dbh,array($this->getLogin(),
                    $this->_idSistema));
        $re  = $res->fetchRow(DB_FETCHMODE_ASSOC);
        if ($re['login']) {
            return new PEAR_Error('El usuario seleccionado ya esta cargado. Modifique sus opciones.');
        }
        return 1;
    }
    // -X2C

    // +X2C Operation 386
    /**
     * Metodo estatico que permite asociar un usuario con un perfil en un sistema determinado.
     *
     * @param  DB &$db Conexion a la base de datos
     * @param  string $login Login del usuario que se quiere asociar
     * @param  int $id_perfil Identificador del perfil que se quiere asociar
     * @param  int $id_sistema identificador del sistema en el que se esta haciendo la asociacion
     * @param  int $responsable Login del usuario que esta haciendo los cambios
     *
     * @return mixed
     * @access public
     * @static
     */
    function asociarPerfil(&$db, $login, $id_perfil, $id_sistema, $responsable) // ~X2C
    {
        $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
        
        $usu = new MECON_Usuario($db);
        $tmp = $usu->verificarLogin($login); 
        if ($tmp) {
            if (PEAR::isError($tmp)) {
                return $tmp;
            }
        }
        else {
            return new PEAR_Error('Usuario no reconocido.<br>Recuerde que &eacute;ste debe haberse logueado previamente a Intranet');
        }

        //Asocio el perfil con el usuario en perfil_sist_usuario
        $datos = array ('login'       => $login, 
                        'id_perfil'   => $id_perfil, 
                        'id_sistema'  => $id_sistema, 
                        'responsable' => $responsable);

        $res = $db->autoExecute('samurai.perfil_sist_usuario', $datos, DB_AUTOQUERY_INSERT);
        if (PEAR::isError($res)) {
            return $res;
        }
        
        return 1;
    }
    // -X2C

    // +X2C Operation 396
    /**
     * Devuelve la informacion completa del usuario. Sistemas a los que esta asignado, perfiles que tiene dentro de cada sistema y permisos.
     *
     * @return mixed
     * @access public
     */
    function informacionGeneral() // ~X2C
    {
        $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
        $tmp = $sql['obtener_informacion'];
        $dbh = $this->_db->prepare($tmp);
        $res = $this->_db->execute($dbh,array($this->getLogin()));

        if (PEAR::isError($res)) {
            return $res;
        }
        
        $rta = array();

        while ($re = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
            $rta[$re['id_sistema']]['nombre_sistema'] = $re['nombre_sistema'];
            $rta[$re['id_sistema']]['perfiles'][$re['id_perfil']]['desc_perfil'] =
                $re['desc_perfil'];
            
            $rta[$re['id_sistema']]['perfiles'][$re['id_perfil']]['permisos'][$re['id_permiso']]
                [$re['observaciones']]['desc_permiso'] = $re['desc_permiso'];
            
            $rta[$re['id_sistema']]['perfiles'][$re['id_perfil']]['permisos'][$re['id_permiso']]
                [$re['observaciones']]['observaciones'] = $re['observaciones'];
        }
        
        return $rta;
    }
    // -X2C

    // +X2C Operation 398
    /**
     * Funcion que obtiene la lista de usuarios que tienen al menos un permiso en la intranet.
     *
     * @param  DB &$db Conexion a la base de datos
     * @param  string $login Parte del login a filtrar
     *
     * @return mixed
     * @access public
     * @static
     */
    function filtrarUsuarios(&$db, $login) // ~X2C
    {
        $sql = parse_ini_file(dirname(__FILE__) . '/Usuario/consultas.ini', true);
        $sql = str_replace ('##?##', $login, $sql['obtener_datos_compartido']);
        $db->setFetchMode(DB_FETCHMODE_ASSOC);
        return $db->query($sql);
    }
    // -X2C

    /**
     * Metodo que devuelve los datos necesarios para listar usuarios.
     *
     * @param  SAMURAI_DB &$db Base de Datos
     * @param  int $id_sistema Identificador del sistema
     *
     * @return mixed
     * @access public
     * @static
     */
    function getUsuariosPager(&$db, $id_sistema = null) {

        //@TODO REEMPLAZA A getUsuarios
        if ($id_sistema) {
            $sql = '
                SELECT DISTINCT u.login, u.nombre 
                FROM usuario.Usuario AS u, perfil_sist_usuario AS psu 
                WHERE u.login = psu.login 
                AND psu.id_sistema = '. $id_sistema .' 
                ORDER BY login
                ';
        }
        else {
            $sql = '
                SELECT login, nombre
                FROM usuario.Usuario
                ORDER BY login
                ';
        }
        return $db->query ($sql);
 
    }

} // -X2C Class :SAMURAI_Usuario
?>