lib/SAMURAI/Migrar.php

   1 <?php /* vim: set binary expandtab tabstop=4 shiftwidth=4 textwidth=80:
   2 // +----------------------------------------------------------------------+
   3 // | PHP Version 4                                                        |
   4 // +----------------------------------------------------------------------+
   5 // | Copyright (c) 1997-2003 The PHP Group                                |
   6 // +----------------------------------------------------------------------+
   7 // | This source file is subject to version 2.02 of the PHP license,      |
   8 // | that is bundled with this package in the file LICENSE, and is        |
   9 // | available at through the world-wide-web at                           |
  10 // | http://www.php.net/license/2_02.txt.                                 |
  11 // | If you did not receive a copy of the PHP license and are unable to   |
  12 // | obtain it through the world-wide-web, please send a note to          |
  13 // | license@php.net so we can mail you a copy immediately.               |
  14 // +----------------------------------------------------------------------+
  15 // | Created: jue mar 11 11:37:42 ART 2004                                |
  16 // | Author:  Martin Marrese <mmarre@mecon.gov.ar                         |
  17 // +----------------------------------------------------------------------+
  18 //
  19 // $Id$
  20 */
  21
  22 require_once 'PEAR.php';
  23 require_once 'DB.php';
  24
  25 require_once 'SAMURAI/Sistema.php';
  26 require_once 'SAMURAI/Perfil.php';
  27 require_once 'SAMURAI/Permiso.php';
  28 require_once 'SAMURAI/Usuario.php';
  29
  30
  31 /**
  32  * Clase para el manejo de la migracion de sistemas.
  33  *
  34  * @access public
  35  */
  36 class SAMURAI_Migrar {
  37
  38     /**
  39      * Conexion al host origen
  40      *
  41      * @var    SAMURAI_DB $db_source
  42      * @access protected
  43      */
  44     var $_db_source = null;
  45
  46     /**
  47      * Conexion al host destino
  48      *
  49      * @var    DB $db_dest
  50      * @access protected
  51      */
  52     var $_db_dest = null;
  53
  54     /**
  55      * Sistema con el que se esta trabajando.
  56      *
  57      * @var    SAMURAI_Sistema $sistema
  58      * @access protected
  59      */
  60     var $_sistema = null;
  61
  62     /**
  63      * Login del responsable de la migracion.
  64      *
  65      * @var    string $responsable
  66      * @access protected
  67      */
  68     var $_responsable = null;
  69
  70     /**
  71      * Se encarga de migrar los datos del sistema.
  72      *
  73      * @return mixed
  74      * @access protected
  75      */
  76     function _migrarSistema() {
  77         //Obtengo el id del sistema
  78         $id_sistema = $this->_db_dest->nextId('sistema');
  79         $fecha_inicio = $this->_sistema->getFechaInicio();
  80         $fecha_fin = $this->_sistema->getFechaFin();
  81         $fecha_implementacion = $this->_sistema->getFechaImplementacion();
  82         //Inserto los datos
  83         $datos = array(
  84                     'id_sistema'            => $id_sistema,
  85                     'nombre_sistema'        => $this->_sistema->getNombre(),
  86                     'desc_sistema'          => $this->_sistema->getDescripcion(),
  87                     'fecha_inicio'          => $fecha_inicio ?
  88                         $fecha_inicio->format("%Y-%m-%d") : null,
  89                     'fecha_fin'             => $fecha_fin ?
  90                         $fecha_fin->format("%Y-%m-%d") : null,
  91                     'fecha_implementacion'  => $fecha_implementacion ?
  92                         $fecha_implementacion->format("%Y-%m-%d") : null,
  93                     'contacto'              => $this->_sistema->getContacto(),
  94                     'estado'                => $this->_sistema->getEstado(),
  95                     'responsable'           => $this->_responsable
  96                 );
  97         $res = $this->_db_dest->autoExecute('samurai.sistema', $datos,
  98                 DB_AUTOQUERY_INSERT);
  99         if (PEAR::isError($res)) {
 100             return $res;
 101         }
 102         return $id_sistema;
 103     }
 104
 105     /**
 106      * Se encarga de migrar los datos de los permisos asociados al sistema.
 107      *
 108      * @return mixed
 109      * @access protected
 110      */
 111     function _migrarPermisos() {
 112         //Obtengo la lista de permisos del sistema origen.
 113         $permisos_source = SAMURAI_Permiso::getArrayPermisos($this->_db_source,
 114                 $this->_sistema->getId());
 115         $permisos_dest = SAMURAI_Permiso::getArrayPermisos($this->_db_dest);
 116         foreach ($permisos_source as $key => $value) {
 117             if (in_array($value, $permisos_dest)) {
 118                 //Existe. Guardo el ID.
 119                 $res[$key] = array_search($value, $permisos_dest);
 120             }
 121             else {
 122                 //No existe. Lo agrego a la base y guardo el id.
 123                 //Obtengo el siguiente ID
 124                 $id_permiso = $this->_db_dest->nextId('permiso');
 125                 //Grabo la info
 126                 $datos = array (
 127                         'id_permiso'   => $id_permiso,
 128                         'desc_permiso' => $value,
 129                         'responsable'  => $this->_responsable,
 130                         );
 131                 $res =  $this->_db->autoExecute('samurai.permiso', $datos, DB_AUTOQUERY_INSERT);
 132                 if (PEAR::isError($res)) {
 133                     return $res;
 134                 }
 135                 $res[$key] = $id_permiso;
 136
 137             }
 138         }
 139         return $res;
 140     }
 141
 142     /**
 143      * Se encarga de migrar los datos de los perfiles asociados al sistema.
 144      *
 145      * @return mixed
 146      * @access protected
 147      */
 148     function _migrarPerfiles() {
 149         //Obtengo la lista de perfiles del sistema origen.
 150         $perfiles_source = SAMURAI_Perfil::getArrayPerfiles($this->_db_source,
 151                 null, $this->_sistema->getId());
 152         $perfiles_dest = SAMURAI_Perfil::getArrayPerfiles($this->_db_dest);
 153         foreach ($perfiles_source as $key => $value) {
 154             if (in_array($value, $perfiles_dest)) {
 155                 //Existe. Guardo el ID.
 156                 $res[$key] = array_search($value, $perfiles_dest);
 157             }
 158             else {
 159                 //No existe. Lo agrego a la base y guardo el id.
 160                 //Obtengo el siguiente ID
 161                 $id_perfil = $this->_db->nextId('perfil');
 162                 //Grabo la info
 163                 $datos = array (
 164                         'id_perfil'   => $id_perfil,
 165                         'desc_perfil' => $value,
 166                         'responsable' => $this->_responsable,
 167                         );
 168                 $res = $this->_db->autoExecute('samurai.perfil', $datos, DB_AUTOQUERY_INSERT);
 169                 if (PEAR::isError($res)) {
 170                     return $res;
 171                 }
 172                 $res[$key] = $id_perfil;
 173
 174             }
 175         }
 176         return $res;
 177     }
 178
 179     /**
 180      * Se encarga de migrar los datos de los usuarios asociados al sistema.
 181      *
 182      * @return mixed
 183      * @access protected
 184      */
 185     function _migrarUsuarios() {
 186         //No hago nada porque solamente tengo que armar las relaciones, si el
 187         //usuario no existe tiene que loguearse al menos una vez en la intranet
 188         //del host destino. Cuando se logue va a existir, por lo tanto va a
 189         //tener el permiso dado.
 190         $res = SAMURAI_Usuario::getArrayUsuarios($this->_db_source,
 191                 $this->_sistema->getId()) ;
 192         return $res;
 193     }
 194
 195     /**
 196      * Se encarga de migrar las relaciones del sistema seleccionado.
 197      *
 198      * @param int   $sistema  Identificador del sistmea en el host destino.
 199      * @param array $permisos Array $permiso[clave_source] = $clave_destino.
 200      * @param array $perfiles Array $perfil[clave_source] = $clave_destino.
 201      * @param array $usuarios Array $usuario[login] = nombre. Usuarios del
 202      *                        sistema en el host source.
 203      *
 204      * @return mixed
 205      * @access protected
 206      */
 207     function _migrarRelaciones($sistema, $permisos, $perfiles, $usuarios) {
 208         $sistema_source = $this->_sistema->getId();
 209         //PERMISO - SISTEMA           perm_sist (OBSERVACIONES)
 210         $res = $this->_relacionPermisoSistema($sistema, $permisos);
 211         if (PEAR::isError($res)) {
 212             return $res;
 213         }
 214         //PERFIL  - SISTEMA           perfil_sist
 215         $res = $this->_relacionPerfilSistema($sistema, $perfiles);
 216         if (PEAR::isError($res)) {
 217             return $res;
 218         }
 219         //PERMISO - PERFIL  - SISTEMA perm_perfil_sist
 220         $res = $this->_relacionPermisoPerfilSistema($sistema, $perfiles,
 221                 $permisos);
 222         if (PEAR::isError($res)) {
 223             return $res;
 224         }
 225         //PERFIL  - SISTEMA - USUARIO perfil_sist_usuario
 226         $res = $this->_relacionPerfilSistemaUsuario($sistema, $perfiles,
 227                 $usuarios);
 228         if (PEAR::isError($res)) {
 229             return $res;
 230         }
 231     }
 232
 233     /**
 234      * Migra la relacion de los permisos del sistema de un host a otro.
 235      *
 236      * @param int   $id_sistema Identificador del sistmea en el host destino.
 237      * @param array $permisos   Array $permiso[clave_source] = $clave_destino.
 238      *
 239      * @return mixed
 240      * @access protected
 241      */
 242     function _relacionPermisoSistema($id_sistema, $permisos) {
 243         $sistema_source = $this->_sistema->getId();
 244         $sql = "
 245             SELECT id_permiso, observaciones
 246             FROM samurai.perm_sist
 247             WHERE id_sistema = $sistema_source
 248             ";
 249         $res = $this->_db_source->getAssoc($sql);
 250         if (PEAR::isError($res)) {
 251             return $res;
 252         }
 253         $sql = $this->_db_dest->prepare("
 254                 INSERT INTO samurai.perm_sist
 255                 (id_permiso, id_sistema, observaciones, responsable)
 256                 VALUES (?, ? , ? , ?)
 257                 ");
 258         foreach ($res as $key => $value) {
 259             //Busco el nuevo id del permiso
 260             if (array_key_exists($key, $permisos)) {
 261                 $id_permiso = $permisos[$key];
 262             }
 263             else {
 264                 return new PEAR_Error ('Se estan realizando modificaciones en el
 265                         host source.', null, null, null, 'HTML');
 266             }
 267             //Agrego la info en la base
 268             $res = $this->_db_dest->execute($sql, array ($id_permiso,
 269                     $id_sistema, $value, $this->_responsable));
 270             if (PEAR::isError($res)) {
 271                 return $res;
 272             }
 273         }
 274     }
 275
 276     /**
 277      * Migra la relacion de los perfiles del sistema de un host a otro.
 278      *
 279      * @param int   $id_sistema Identificador del sistmea en el host destino.
 280      * @param array $perfiles   Array $perfil[clave_source] = $clave_destino.
 281      *
 282      * @return mixed
 283      * @access protected
 284      */
 285     function _relacionPerfilSistema($id_sistema, $perfiles) {
 286         $sistema_source = $this->_sistema->getId();
 287         //Asocio los perfiles al sistema
 288         $sql = "
 289             SELECT id_perfil
 290             FROM samurai.perfil_sist
 291             WHERE id_sistema = $sistema_source
 292             ";
 293         $res = $this->_db_source->getCol($sql);
 294         if (PEAR::isError($res)) {
 295             return $res;
 296         }
 297         $sql = $this->_db_dest->prepare("
 298                 INSERT INTO samurai.perfil_sist
 299                 (id_perfil, id_sistema, responsable)
 300                 VALUES (?, ? , ?)
 301                 ");
 302         foreach ($res as $key) {
 303             //Busco el nuevo id del perfil
 304             if (array_key_exists($key, $perfiles)) {
 305                 $id_perfil = $perfiles[$key];
 306             }
 307             else {
 308                 return new PEAR_Error ('Se estan realizando modificaciones en el
 309                         host source.', null, null, null, 'HTML');
 310             }
 311             //Agrego la info en la base
 312             $res = $this->_db_dest->execute($sql, array ($id_perfil,
 313                     $id_sistema, $this->_responsable));
 314             if (PEAR::isError($res)) {
 315                 return $res;
 316             }
 317         }
 318     }
 319
 320     /**
 321      * Migra la relacion de los perfiles del sistema con permisos de un host a
 322      * otro.
 323      *
 324      * @param int   $id_sistema Identificador del sistmea en el host destino.
 325      * @param array $perfiles   Array $perfil[clave_source] = $clave_destino.
 326      * @param array $permisos   Array $permiso[clave_source] = $clave_destino.
 327      *
 328      * @return mixed
 329      * @access protected
 330      */
 331     function _relacionPermisoPerfilSistema($id_sistema, $perfiles, $permisos) {
 332         $sistema_source = $this->_sistema->getId();
 333         //Asocio los perfiles al sistema con permisos
 334         $sql = "
 335             SELECT id_permiso, id_perfil, id_sistema, observaciones
 336             FROM samurai.perm_perfil_sist
 337             WHERE id_sistema = $sistema_source
 338             ";
 339         $res = $this->_db_source->getAll($sql);
 340         if (PEAR::isError($res)) {
 341             return $res;
 342         }
 343         $sql = $this->_db_dest->prepare("
 344                 INSERT INTO samurai.perm_perfil_sist
 345                 (id_permiso, id_perfil, id_sistema, observaciones, responsable)
 346                 VALUES (?, ?, ?, ?, ?)
 347                 ");
 348         foreach ($res as $value) {
 349             if (array_key_exists($value[0], $permisos)) {
 350                 $id_permiso = $permisos[$value[0]];
 351             }
 352             else {
 353                 return new PEAR_Error ('Se estan realizando modificaciones en el
 354                         host source.', null, null, null, 'HTML');
 355             }
 356             if (array_key_exists($value[1], $perfiles)) {
 357                 $id_perfil = $perfiles[$value[1]];
 358             }
 359             else {
 360                 return new PEAR_Error ('Se estan realizando modificaciones en el
 361                         host source.', null, null, null, 'HTML');
 362             }
 363             $res = $this->_db_dest->execute($sql, array ($id_permiso,
 364                         $id_perfil, $id_sistema, $value[2], $this->_responsable));
 365             if (PEAR::isError($res)) {
 366                 return $res;
 367             }
 368         }
 369     }
 370
 371     /**
 372      * Migra la relacion de los usuarios con perfiles del sistema con permisos
 373      * de un host a  otro.
 374      *
 375      * @param int   $id_sistema Identificador del sistmea en el host destino.
 376      * @param array $perfiles   Array $perfil[clave_source] = $clave_destino.
 377      * @param array $usuarios   Array $usuario[login] = nombre.
 378      *
 379      * @return mixed
 380      * @access protected
 381      */
 382     function _relacionPerfilSistemaUsuarios($id_sistema, $perfiles, $usuarios) {
 383         $sistema_source = $this->_sistema->getId();
 384         //Asocio los usuarios al perfil en le sistema
 385         $sql = "
 386             SELECT login, id_perfil, id_sistema
 387             FROM samurai.perfil_sist_usuario
 388             WHERE id_sistema = $sistema_source
 389             ";
 390         $res = $this->_db_source->getAll($sql);
 391         if (PEAR::isError($res)) {
 392             return $res;
 393         }
 394         $sql = $this->_db_dest->prepare("
 395                 INSERT INTO samurai.perfil_sist_usuario
 396                 (login, id_perfil, id_sistema, responsable)
 397                 VALUES (?, ?, ?, ?)
 398                 ");
 399         foreach ($res as $value) {
 400             if (array_key_exists($value[1], $perfiles)) {
 401                 $id_perfil = $perfiles[$value[1]];
 402             }
 403             else {
 404                 return new PEAR_Error ('Se estan realizando modificaciones en el
 405                         host source.', null, null, null, 'HTML');
 406             }
 407             $res = $this->_db_dest->execute($sql, array ($value[0], $id_perfil,
 408                         $id_sistema, $this->_responsable));
 409             if (PEAR::isError($res)) {
 410                 return $res;
 411             }
 412         }
 413     }
 414
 415     /**
 416      * Verifica si existe en el host destino un sistema con igual nombre.
 417      *
 418      * @return mixed
 419      * @access protected
 420      */
 421     function _verificarExisteSistema() {
 422         $sql = "
 423             SELECT count(*) AS cuenta
 424             FROM   samurai.sistema
 425             WHERE  nombre_sistema = ".
 426             $this->_db_dest->quote($this->_sistema->getNombre());
 427         $res = $this->_db_dest->getCol($sql);
 428         if (PEAR::isError($res)) {
 429             return $res;
 430         }
 431         elseif (array_shift($res)) {
 432             return new PEAR_Error ('El sistema ya existe en el host
 433                     seleccionado.', null, null, null, 'HTML');
 434         }
 435     }
 436
 437     /**
 438      * Realiza la conexion con el host destino
 439      *
 440      * @param string $db_host Identificador del servidor MySQL.
 441      * @param string $db_user Identificador del usuario MySQL con permisos en la
 442      *                        base samurai en el host ingresado.
 443      * @param string $db_pass Clave del usuario MySQL.
 444      *
 445      * @return mixed
 446      * @access protected
 447      */
 448     function _dbDestino($db_host, $db_user, $db_pass) {
 449         return  DB::connect(
 450                 "mysql://$db_user:$db_pass@$db_host/samurai"
 451                 ,true
 452                 );
 453     }
 454
 455     /**
 456      * Constructor.
 457      *
 458      * @param DB &$db_source Conexion a la base de datos.
 459      * @param string $db_host Identificador del servidor MySQL.
 460      * @param string $db_user Identificador del usuario MySQL con permisos en la
 461      *                        base samurai en el host ingresado.
 462      * @param string $db_pass Clave del usuario MySQL.
 463      * @param string $responsable Login del responsable de la migracion.
 464      *
 465      * @return void
 466      * @access public
 467      */
 468     function SAMURAI_Migrar(&$db_source, $db_host, $db_user, $db_pass,
 469             $responsable) {
 470         $this->_db_source =& $db_source;
 471         $this->_responsable = $responsable;
 472         //Armo la conexion con el host destino
 473         $this->_db_dest =& $this->_dbDestino($db_host, $db_user, $db_pass);
 474         if (PEAR::isError($this->_db_dest)) {
 475             trigger_error('Error: ' . $this->_db_dest->getMessage() . "\n", E_USER_ERROR);
 476         }
 477     }
 478
 479     /**
 480      * Se encarga de migrar el sistema, que se selecciono, completo (permisos,
 481      * sistema, perfiles, usuarios) al destino ingresado.
 482      *
 483      * @param int $id_sistema Identificador del sistema.
 484      *
 485      * @return mixed
 486      * @access public
 487      */
 488     function migrarSistema($id_sistema) {
 489
 490         //Lockear las tablas en el host source para escritura con la sentencia
 491         //sql lock
 492
 493         $this->_sistema =& new SAMURAI_Sistema($this->_db_source, $id_sistema);
 494
 495         //Verifico si existe el sistema.
 496         $res = $this->_verificarExisteSistema();
 497         if (PEAR::isError($res)) {
 498             return $res
 499         }
 500         //Migro los permisos.
 501         $permisos = $this->_migrarPermisos();
 502         if (PEAR::isError($permisos)) {
 503             return $permisos;
 504         }
 505         //Migro el sistema.
 506         $sistema = $this->_migrarSistema();
 507         if (PEAR::isError($sistema)) {
 508             return $sistema;
 509         }
 510         //Migro los perfiles.
 511         $perfiles = $this->_migrarPerfiles();
 512         if (PEAR::isError($perfiles)) {
 513             return $perfiles;
 514         }
 515         //Migro los usuarios.
 516         $usuarios = $this->_migrarUsuarios();
 517         if (PEAR::isError($usuarios)) {
 518             return $usuarios;
 519         }
 520         //Migro las relaciones
 521         $relaciones = $this->_migrarRelaciones($sistema, $permisos, $perfiles,
 522                 $usuarios);
 523         if (PEAR::isError($relaciones)) {
 524             return $relaciones;
 525         }
 526         //Deslockear las tablas en el host source para escritura con la sentencia
 527         //sql lock
 528     }
 529 }
 530 ?>