<?php /* vim: set binary expandtab tabstop=4 shiftwidth=4 textwidth=80:
// +----------------------------------------------------------------------+
// | 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: jue mar 11 11:37:42 ART 2004                                |
// | Author:  Martin Marrese <mmarre@mecon.gov.ar                         |
// +----------------------------------------------------------------------+
//
// $Id$
*/

require_once 'PEAR.php';
require_once 'DB.php';

require_once 'SAMURAI/Sistema.php';
require_once 'SAMURAI/Perfil.php';
require_once 'SAMURAI/Permiso.php';
require_once 'SAMURAI/Usuario.php';


/**
 * Clase para el manejo de la migracion de sistemas.
 *
 * @access public
 */
class SAMURAI_Migrar {

    /**
     * Conexion al host origen
     *
     * @var    SAMURAI_DB $db_source
     * @access protected
     */
    var $_db_source = null;

    /**
     * Conexion al host destino
     *
     * @var    DB $db_dest
     * @access protected
     */
    var $_db_dest = null;

    /**
     * Sistema con el que se esta trabajando.
     *
     * @var    SAMURAI_Sistema $sistema
     * @access protected
     */
    var $_sistema = null;

    /**
     * Login del responsable de la migracion.
     *
     * @var    string $responsable
     * @access protected
     */
    var $_responsable = null;

    /**
     * Se encarga de migrar los datos del sistema.
     *
     * @return mixed
     * @access protected
     */
    function _migrarSistema() {
        //Obtengo el id del sistema
        $id_sistema = $this->_db_dest->nextId('sistema');
        $fecha_inicio = $this->_sistema->getFechaInicio();
        $fecha_fin = $this->_sistema->getFechaFin();
        $fecha_implementacion = $this->_sistema->getFechaImplementacion();
        //Inserto los datos
        $datos = array(  
                    'id_sistema'            => $id_sistema,
                    'nombre_sistema'        => $this->_sistema->getNombre(),
                    'desc_sistema'          => $this->_sistema->getDescripcion(),
                    'fecha_inicio'          => $fecha_inicio ? 
                        $fecha_inicio->format("%Y-%m-%d") : null, 
                    'fecha_fin'             => $fecha_fin ? 
                        $fecha_fin->format("%Y-%m-%d") : null, 
                    'fecha_implementacion'  => $fecha_implementacion ? 
                        $fecha_implementacion->format("%Y-%m-%d") : null,
                    'contacto'              => $this->_sistema->getContacto(),
                    'estado'                => $this->_sistema->getEstado(),
                    'responsable'           => $this->_responsable
                );                
        $res = $this->_db_dest->autoExecute('samurai.sistema', $datos, 
                DB_AUTOQUERY_INSERT);
        if (PEAR::isError($res)) {
            return $res;
        }
        return $id_sistema;
    }
    
    /**
     * Se encarga de migrar los datos de los permisos asociados al sistema.
     *
     * @return mixed
     * @access protected
     */
    function _migrarPermisos() {
        //Obtengo la lista de permisos del sistema origen.
        $permisos_source = SAMURAI_Permiso::getArrayPermisos($this->_db_source,
                $this->_sistema->getId());
        $permisos_dest = SAMURAI_Permiso::getArrayPermisos($this->_db_dest);
        foreach ($permisos_source as $key => $value) {
            if (in_array($value, $permisos_dest)) {
                //Existe. Guardo el ID.
                $res[$key] = array_search($value, $permisos_dest);
            }
            else {
                //No existe. Lo agrego a la base y guardo el id.
                //Obtengo el siguiente ID
                $id_permiso = $this->_db_dest->nextId('permiso');
                //Grabo la info
                $datos = array (
                        'id_permiso'   => $id_permiso,
                        'desc_permiso' => $value,
                        'responsable'  => $this->_responsable,
                        );
                $tmp =  $this->_db_dest->autoExecute('samurai.permiso', $datos, DB_AUTOQUERY_INSERT);
                if (PEAR::isError($tmp)) {
                    return $tmp;
                }
                $res[$key] = $id_permiso;
            }
        }
        return $res;
    }

    /**
     * Se encarga de migrar los datos de los perfiles asociados al sistema.
     * 
     * @return mixed
     * @access protected
     */
    function _migrarPerfiles() {
        //Obtengo la lista de perfiles del sistema origen.
        $perfiles_source = SAMURAI_Perfil::getArrayPerfiles($this->_db_source,
                null, $this->_sistema->getId());
        $perfiles_dest = SAMURAI_Perfil::getArrayPerfiles($this->_db_dest);
        foreach ($perfiles_source as $key => $value) {
            if (in_array($value, $perfiles_dest)) {
                //Existe. Guardo el ID.
                $res[$key] = array_search($value, $perfiles_dest);
            }
            else {
                //No existe. Lo agrego a la base y guardo el id.
                //Obtengo el siguiente ID
                $id_perfil = $this->_db_dest->nextId('perfil');
                //Grabo la info
                $datos = array (
                        'id_perfil'   => $id_perfil,
                        'desc_perfil' => $value,
                        'responsable' => $this->_responsable,
                        );
                $tmp = $this->_db_dest->autoExecute('samurai.perfil', $datos, DB_AUTOQUERY_INSERT);
                if (PEAR::isError($tmp)) {
                    return $tmp;
                }
                $res[$key] = $id_perfil;
                    
            }
        }
        return $res;
    }

    /**
     * Se encarga de migrar los datos de los usuarios asociados al sistema.
     *
     * @return mixed
     * @access protected
     */
    function _migrarUsuarios() {
        //No hago nada porque solamente tengo que armar las relaciones, si el
        //usuario no existe tiene que loguearse al menos una vez en la intranet
        //del host destino. Cuando se logue va a existir, por lo tanto va a
        //tener el permiso dado.
        $res = SAMURAI_Usuario::getArrayUsuarios($this->_db_source,
                $this->_sistema->getId()) ;
        return $res;
    }

    /**
     * Se encarga de migrar las relaciones del sistema seleccionado.
     *
     * @param int   $sistema  Identificador del sistmea en el host destino.
     * @param array $permisos Array $permiso[clave_source] = $clave_destino.
     * @param array $perfiles Array $perfil[clave_source] = $clave_destino.
     * @param array $usuarios Array $usuario[login] = nombre. Usuarios del
     *                        sistema en el host source.
     *
     * @return mixed
     * @access protected
     */
    function _migrarRelaciones($sistema, $permisos, $perfiles, $usuarios) {
        $sistema_source = $this->_sistema->getId();
        //PERMISO - SISTEMA           perm_sist (OBSERVACIONES)
        $res = $this->_relacionPermisoSistema($sistema, $permisos);
        if (PEAR::isError($res)) {
            return $res;
        }
        //PERFIL  - SISTEMA           perfil_sist
        $res = $this->_relacionPerfilSistema($sistema, $perfiles);
        if (PEAR::isError($res)) {
            return $res;
        }
        //PERMISO - PERFIL  - SISTEMA perm_perfil_sist
        $res = $this->_relacionPermisoPerfilSistema($sistema, $perfiles, 
                $permisos);
        if (PEAR::isError($res)) {
            return $res;
        }
        //PERFIL  - SISTEMA - USUARIO perfil_sist_usuario
        $res = $this->_relacionPerfilSistemaUsuario($sistema, $perfiles,
                $usuarios);
        if (PEAR::isError($res)) {
            return $res;
        }
    }

    /**
     * Migra la relacion de los permisos del sistema de un host a otro.
     *
     * @param int   $id_sistema Identificador del sistmea en el host destino.
     * @param array $permisos   Array $permiso[clave_source] = $clave_destino.
     *
     * @return mixed
     * @access protected
     */
    function _relacionPermisoSistema($id_sistema, $permisos) {
        $sistema_source = $this->_sistema->getId();
        $sql = "
            SELECT id_permiso, observaciones
            FROM samurai.perm_sist
            WHERE id_sistema = $sistema_source
            ";
        $res = $this->_db_source->getAssoc($sql);
        if (PEAR::isError($res)) {
            return $res;
        }
        $sql = $this->_db_dest->prepare("
                INSERT INTO samurai.perm_sist
                (id_permiso, id_sistema, observaciones, responsable)
                VALUES (?, ? , ? , ?)
                ");
        foreach ($res as $key => $value) {
            //Busco el nuevo id del permiso
            if (array_key_exists($key, $permisos)) {
                $id_permiso = $permisos[$key];
            }
            else {
                return new PEAR_Error ('Se estan realizando modificaciones en el
                        host source.', null, null, null, 'HTML');
            }
            //Agrego la info en la base
            $res = $this->_db_dest->execute($sql, array ($id_permiso,
                    $id_sistema, $value, $this->_responsable));
            if (PEAR::isError($res)) {
                return $res;
            }
        }
    }

    /**
     * Migra la relacion de los perfiles del sistema de un host a otro.
     *
     * @param int   $id_sistema Identificador del sistmea en el host destino.
     * @param array $perfiles   Array $perfil[clave_source] = $clave_destino.
     *
     * @return mixed
     * @access protected
     */
    function _relacionPerfilSistema($id_sistema, $perfiles) {
        $sistema_source = $this->_sistema->getId();
        //Asocio los perfiles al sistema
        $sql = "
            SELECT id_perfil
            FROM samurai.perfil_sist
            WHERE id_sistema = $sistema_source
            ";
        $res = $this->_db_source->getCol($sql);
        if (PEAR::isError($res)) {
            return $res;
        }
        $sql = $this->_db_dest->prepare("
                INSERT INTO samurai.perfil_sist
                (id_perfil, id_sistema, responsable)
                VALUES (?, ? , ?)
                ");
        foreach ($res as $key) {
            //Busco el nuevo id del perfil
            if (array_key_exists($key, $perfiles)) {
                $id_perfil = $perfiles[$key];
            }
            else {
                return new PEAR_Error ('Se estan realizando modificaciones en el
                        host source.', null, null, null, 'HTML');
            }
            //Agrego la info en la base
            $res = $this->_db_dest->execute($sql, array ($id_perfil,
                    $id_sistema, $this->_responsable));
            if (PEAR::isError($res)) {
                return $res;
            }
        }
    }

    /**
     * Migra la relacion de los perfiles del sistema con permisos de un host a 
     * otro.
     *
     * @param int   $id_sistema Identificador del sistmea en el host destino.
     * @param array $perfiles   Array $perfil[clave_source] = $clave_destino.
     * @param array $permisos   Array $permiso[clave_source] = $clave_destino.
     *
     * @return mixed
     * @access protected
     */
    function _relacionPermisoPerfilSistema($id_sistema, $perfiles, $permisos) {
        $sistema_source = $this->_sistema->getId();
        //Asocio los perfiles al sistema con permisos
        $sql = "
            SELECT id_permiso, id_perfil, id_sistema, observaciones
            FROM samurai.perm_perfil_sist
            WHERE id_sistema = $sistema_source
            ";
        $res = $this->_db_source->getAll($sql);
        if (PEAR::isError($res)) {
            return $res;
        }
        $sql = $this->_db_dest->prepare("
                INSERT INTO samurai.perm_perfil_sist
                (id_permiso, id_perfil, id_sistema, observaciones, responsable)
                VALUES (?, ?, ?, ?, ?)
                ");
        foreach ($res as $value) {
            if (array_key_exists($value[0], $permisos)) {
                $id_permiso = $permisos[$value[0]];
            }
            else {
                return new PEAR_Error ('Se estan realizando modificaciones en el
                        host source.', null, null, null, 'HTML');
            }
            if (array_key_exists($value[1], $perfiles)) {
                $id_perfil = $perfiles[$value[1]];
            }
            else {
                return new PEAR_Error ('Se estan realizando modificaciones en el
                        host source.', null, null, null, 'HTML');
            }
            $res = $this->_db_dest->execute($sql, array ($id_permiso, 
                        $id_perfil, $id_sistema, $value[2], $this->_responsable));
            if (PEAR::isError($res)) {
                return $res;
            }
        }
    }

    /**
     * Migra la relacion de los usuarios con perfiles del sistema con permisos 
     * de un host a  otro.
     *
     * @param int   $id_sistema Identificador del sistmea en el host destino.
     * @param array $perfiles   Array $perfil[clave_source] = $clave_destino.
     * @param array $usuarios   Array $usuario[login] = nombre.
     *
     * @return mixed
     * @access protected
     */
    function _relacionPerfilSistemaUsuario($id_sistema, $perfiles, $usuarios) {
        $sistema_source = $this->_sistema->getId();
        //Asocio los usuarios al perfil en le sistema
        $sql = "
            SELECT login, id_perfil, id_sistema
            FROM samurai.perfil_sist_usuario
            WHERE id_sistema = $sistema_source
            ";
        $res = $this->_db_source->getAll($sql);
        if (PEAR::isError($res)) {
            return $res;
        }
        $sql = $this->_db_dest->prepare("
                INSERT INTO samurai.perfil_sist_usuario
                (login, id_perfil, id_sistema, responsable)
                VALUES (?, ?, ?, ?)
                ");
        foreach ($res as $value) {
            if (array_key_exists($value[1], $perfiles)) {
                $id_perfil = $perfiles[$value[1]];
            }
            else {
                return new PEAR_Error ('Se estan realizando modificaciones en el
                        host source.', null, null, null, 'HTML');
            }
            $res = $this->_db_dest->execute($sql, array ($value[0], $id_perfil,
                        $id_sistema, $this->_responsable));
            if (PEAR::isError($res)) {
                return $res;
            }
        }
    }

    /**
     * Verifica si existe en el host destino un sistema con igual nombre. 
     *
     * @return mixed
     * @access protected
     */
    function _verificarExisteSistema() {
        $sql = "
            SELECT count(*) AS cuenta
            FROM   samurai.sistema
            WHERE  nombre_sistema = ". 
            $this->_db_dest->quote($this->_sistema->getNombre());
        $res = $this->_db_dest->getCol($sql);
        if (PEAR::isError($res)) {
            return $res;
        }
        elseif (array_shift($res)) {
            return new PEAR_Error ('El sistema ya existe en el host
                    seleccionado.', null, null, null, 'HTML');
        }
    }
    
    /**
     * Realiza la conexion con el host destino
     *
     * @param string $db_host Identificador del servidor MySQL.
     * @param string $db_user Identificador del usuario MySQL con permisos en la
     *                        base samurai en el host ingresado.
     * @param string $db_pass Clave del usuario MySQL.
     *
     * @return mixed
     * @access protected
     */
    function _dbDestino($db_host, $db_user, $db_pass) {
        return  DB::connect(
                "mysql://$db_user:$db_pass@$db_host/samurai"
                ,true
                );
    }

    /**
     * Constructor.
     *
     * @param DB &$db_source Conexion a la base de datos.
     * @param string $db_host Identificador del servidor MySQL.
     * @param string $db_user Identificador del usuario MySQL con permisos en la
     *                        base samurai en el host ingresado.
     * @param string $db_pass Clave del usuario MySQL.
     * @param string $responsable Login del responsable de la migracion.
     *
     * @return void
     * @access public
     */
    function SAMURAI_Migrar(&$db_source, $db_host, $db_user, $db_pass,
            $responsable) {
        $this->_db_source =& $db_source;
        $this->_responsable = $responsable;
        //Armo la conexion con el host destino
        $this->_db_dest =& $this->_dbDestino($db_host, $db_user, $db_pass);
        if (PEAR::isError($this->_db_dest)) {
            trigger_error('Error: ' . $this->_db_dest->getMessage() . "\n", E_USER_ERROR);
        }
    }

    /**
     * Se encarga de migrar el sistema, que se selecciono, completo (permisos, 
     * sistema, perfiles, usuarios) al destino ingresado.
     *
     * @param int $id_sistema Identificador del sistema. 
     *
     * @return mixed
     * @access public
     */
    function migrarSistema($id_sistema) {

        //Lockear las tablas en el host source para escritura con la sentencia
        //sql lock
        $this->_sistema =& new SAMURAI_Sistema($this->_db_source, $id_sistema);

        //Verifico si existe el sistema.
        $res = $this->_verificarExisteSistema();
        if (PEAR::isError($res)) {
            return $res;
        }
        //Migro los permisos.
        $permisos = $this->_migrarPermisos();
        if (PEAR::isError($permisos)) {
            return $permisos;
        }
        //Migro el sistema.
        $sistema = $this->_migrarSistema();
        if (PEAR::isError($sistema)) {
            return $sistema;
        }
        //Migro los perfiles.
        $perfiles = $this->_migrarPerfiles();
        if (PEAR::isError($perfiles)) {
            return $perfiles;
        }
        //Migro los usuarios.
        $usuarios = $this->_migrarUsuarios();
        if (PEAR::isError($usuarios)) {
            return $usuarios;
        }
        //Migro las relaciones
        $relaciones = $this->_migrarRelaciones($sistema, $permisos, $perfiles,
                $usuarios);
        if (PEAR::isError($relaciones)) {
            return $relaciones;
        }
        //Deslockear las tablas en el host source para escritura con la sentencia
        //sql lock
    }
}  
?>