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                 $tmp =  $this->_db_dest->autoExecute('samurai.permiso', $datos, DB_AUTOQUERY_INSERT);
 132                 if (PEAR::isError($tmp)) {
 133                     return $tmp;
 134                 }
 135                 $res[$key] = $id_permiso;
 136             }
 137         }
 138         return $res;
 139     }
 140
 141     /**
 142      * Se encarga de migrar los datos de los perfiles asociados al sistema.
 143      *
 144      * @return mixed
 145      * @access protected
 146      */
 147     function _migrarPerfiles() {
 148         //Obtengo la lista de perfiles del sistema origen.
 149         $perfiles_source = SAMURAI_Perfil::getArrayPerfiles($this->_db_source,
 150                 null, $this->_sistema->getId());
 151         $perfiles_dest = SAMURAI_Perfil::getArrayPerfiles($this->_db_dest);
 152         foreach ($perfiles_source as $key => $value) {
 153             if (in_array($value, $perfiles_dest)) {
 154                 //Existe. Guardo el ID.
 155                 $res[$key] = array_search($value, $perfiles_dest);
 156             }
 157             else {
 158                 //No existe. Lo agrego a la base y guardo el id.
 159                 //Obtengo el siguiente ID
 160                 $id_perfil = $this->_db_dest->nextId('perfil');
 161                 //Grabo la info
 162                 $datos = array (
 163                         'id_perfil'   => $id_perfil,
 164                         'desc_perfil' => $value,
 165                         'responsable' => $this->_responsable,
 166                         );
 167                 $tmp = $this->_db_dest->autoExecute('samurai.perfil', $datos, DB_AUTOQUERY_INSERT);
 168                 if (PEAR::isError($tmp)) {
 169                     return $tmp;
 170                 }
 171                 $res[$key] = $id_perfil;
 172
 173             }
 174         }
 175         return $res;
 176     }
 177
 178     /**
 179      * Se encarga de migrar los datos de los usuarios asociados al sistema.
 180      *
 181      * @return mixed
 182      * @access protected
 183      */
 184     function _migrarUsuarios() {
 185         //No hago nada porque solamente tengo que armar las relaciones, si el
 186         //usuario no existe tiene que loguearse al menos una vez en la intranet
 187         //del host destino. Cuando se logue va a existir, por lo tanto va a
 188         //tener el permiso dado.
 189         $res = SAMURAI_Usuario::getArrayUsuarios($this->_db_source,
 190                 $this->_sistema->getId()) ;
 191         return $res;
 192     }
 193
 194     /**
 195      * Se encarga de migrar las relaciones del sistema seleccionado.
 196      *
 197      * @param int   $sistema  Identificador del sistmea en el host destino.
 198      * @param array $permisos Array $permiso[clave_source] = $clave_destino.
 199      * @param array $perfiles Array $perfil[clave_source] = $clave_destino.
 200      * @param array $usuarios Array $usuario[login] = nombre. Usuarios del
 201      *                        sistema en el host source.
 202      *
 203      * @return mixed
 204      * @access protected
 205      */
 206     function _migrarRelaciones($sistema, $permisos, $perfiles, $usuarios) {
 207         $sistema_source = $this->_sistema->getId();
 208         //PERMISO - SISTEMA           perm_sist (OBSERVACIONES)
 209         $res = $this->_relacionPermisoSistema($sistema, $permisos);
 210         if (PEAR::isError($res)) {
 211             return $res;
 212         }
 213         //PERFIL  - SISTEMA           perfil_sist
 214         $res = $this->_relacionPerfilSistema($sistema, $perfiles);
 215         if (PEAR::isError($res)) {
 216             return $res;
 217         }
 218         //PERMISO - PERFIL  - SISTEMA perm_perfil_sist
 219         $res = $this->_relacionPermisoPerfilSistema($sistema, $perfiles,
 220                 $permisos);
 221         if (PEAR::isError($res)) {
 222             return $res;
 223         }
 224         //PERFIL  - SISTEMA - USUARIO perfil_sist_usuario
 225         $res = $this->_relacionPerfilSistemaUsuario($sistema, $perfiles,
 226                 $usuarios);
 227         if (PEAR::isError($res)) {
 228             return $res;
 229         }
 230     }
 231
 232     /**
 233      * Migra la relacion de los permisos del sistema de un host a otro.
 234      *
 235      * @param int   $id_sistema Identificador del sistmea en el host destino.
 236      * @param array $permisos   Array $permiso[clave_source] = $clave_destino.
 237      *
 238      * @return mixed
 239      * @access protected
 240      */
 241     function _relacionPermisoSistema($id_sistema, $permisos) {
 242         $sistema_source = $this->_sistema->getId();
 243         $sql = "
 244             SELECT id_permiso, observaciones
 245             FROM samurai.perm_sist
 246             WHERE id_sistema = $sistema_source
 247             ";
 248         $res = $this->_db_source->getAssoc($sql);
 249         if (PEAR::isError($res)) {
 250             return $res;
 251         }
 252         $sql = $this->_db_dest->prepare("
 253                 INSERT INTO samurai.perm_sist
 254                 (id_permiso, id_sistema, observaciones, responsable)
 255                 VALUES (?, ? , ? , ?)
 256                 ");
 257         foreach ($res as $key => $value) {
 258             //Busco el nuevo id del permiso
 259             if (array_key_exists($key, $permisos)) {
 260                 $id_permiso = $permisos[$key];
 261             }
 262             else {
 263                 return new PEAR_Error ('Se estan realizando modificaciones en el
 264                         host source.', null, null, null, 'HTML');
 265             }
 266             //Agrego la info en la base
 267             $res = $this->_db_dest->execute($sql, array ($id_permiso,
 268                     $id_sistema, $value, $this->_responsable));
 269             if (PEAR::isError($res)) {
 270                 return $res;
 271             }
 272         }
 273     }
 274
 275     /**
 276      * Migra la relacion de los perfiles del sistema de un host a otro.
 277      *
 278      * @param int   $id_sistema Identificador del sistmea en el host destino.
 279      * @param array $perfiles   Array $perfil[clave_source] = $clave_destino.
 280      *
 281      * @return mixed
 282      * @access protected
 283      */
 284     function _relacionPerfilSistema($id_sistema, $perfiles) {
 285         $sistema_source = $this->_sistema->getId();
 286         //Asocio los perfiles al sistema
 287         $sql = "
 288             SELECT id_perfil
 289             FROM samurai.perfil_sist
 290             WHERE id_sistema = $sistema_source
 291             ";
 292         $res = $this->_db_source->getCol($sql);
 293         if (PEAR::isError($res)) {
 294             return $res;
 295         }
 296         $sql = $this->_db_dest->prepare("
 297                 INSERT INTO samurai.perfil_sist
 298                 (id_perfil, id_sistema, responsable)
 299                 VALUES (?, ? , ?)
 300                 ");
 301         foreach ($res as $key) {
 302             //Busco el nuevo id del perfil
 303             if (array_key_exists($key, $perfiles)) {
 304                 $id_perfil = $perfiles[$key];
 305             }
 306             else {
 307                 return new PEAR_Error ('Se estan realizando modificaciones en el
 308                         host source.', null, null, null, 'HTML');
 309             }
 310             //Agrego la info en la base
 311             $res = $this->_db_dest->execute($sql, array ($id_perfil,
 312                     $id_sistema, $this->_responsable));
 313             if (PEAR::isError($res)) {
 314                 return $res;
 315             }
 316         }
 317     }
 318
 319     /**
 320      * Migra la relacion de los perfiles del sistema con permisos de un host a
 321      * otro.
 322      *
 323      * @param int   $id_sistema Identificador del sistmea en el host destino.
 324      * @param array $perfiles   Array $perfil[clave_source] = $clave_destino.
 325      * @param array $permisos   Array $permiso[clave_source] = $clave_destino.
 326      *
 327      * @return mixed
 328      * @access protected
 329      */
 330     function _relacionPermisoPerfilSistema($id_sistema, $perfiles, $permisos) {
 331         $sistema_source = $this->_sistema->getId();
 332         //Asocio los perfiles al sistema con permisos
 333         $sql = "
 334             SELECT id_permiso, id_perfil, id_sistema, observaciones
 335             FROM samurai.perm_perfil_sist
 336             WHERE id_sistema = $sistema_source
 337             ";
 338         $res = $this->_db_source->getAll($sql);
 339         if (PEAR::isError($res)) {
 340             return $res;
 341         }
 342         $sql = $this->_db_dest->prepare("
 343                 INSERT INTO samurai.perm_perfil_sist
 344                 (id_permiso, id_perfil, id_sistema, observaciones, responsable)
 345                 VALUES (?, ?, ?, ?, ?)
 346                 ");
 347         foreach ($res as $value) {
 348             if (array_key_exists($value[0], $permisos)) {
 349                 $id_permiso = $permisos[$value[0]];
 350             }
 351             else {
 352                 return new PEAR_Error ('Se estan realizando modificaciones en el
 353                         host source.', null, null, null, 'HTML');
 354             }
 355             if (array_key_exists($value[1], $perfiles)) {
 356                 $id_perfil = $perfiles[$value[1]];
 357             }
 358             else {
 359                 return new PEAR_Error ('Se estan realizando modificaciones en el
 360                         host source.', null, null, null, 'HTML');
 361             }
 362             $res = $this->_db_dest->execute($sql, array ($id_permiso,
 363                         $id_perfil, $id_sistema, $value[2], $this->_responsable));
 364             if (PEAR::isError($res)) {
 365                 return $res;
 366             }
 367         }
 368     }
 369
 370     /**
 371      * Migra la relacion de los usuarios con perfiles del sistema con permisos
 372      * de un host a  otro.
 373      *
 374      * @param int   $id_sistema Identificador del sistmea en el host destino.
 375      * @param array $perfiles   Array $perfil[clave_source] = $clave_destino.
 376      * @param array $usuarios   Array $usuario[login] = nombre.
 377      *
 378      * @return mixed
 379      * @access protected
 380      */
 381     function _relacionPerfilSistemaUsuario($id_sistema, $perfiles, $usuarios) {
 382         $sistema_source = $this->_sistema->getId();
 383         //Asocio los usuarios al perfil en le sistema
 384         $sql = "
 385             SELECT login, id_perfil, id_sistema
 386             FROM samurai.perfil_sist_usuario
 387             WHERE id_sistema = $sistema_source
 388             ";
 389         $res = $this->_db_source->getAll($sql);
 390         if (PEAR::isError($res)) {
 391             return $res;
 392         }
 393         $sql = $this->_db_dest->prepare("
 394                 INSERT INTO samurai.perfil_sist_usuario
 395                 (login, id_perfil, id_sistema, responsable)
 396                 VALUES (?, ?, ?, ?)
 397                 ");
 398         foreach ($res as $value) {
 399             if (array_key_exists($value[1], $perfiles)) {
 400                 $id_perfil = $perfiles[$value[1]];
 401             }
 402             else {
 403                 return new PEAR_Error ('Se estan realizando modificaciones en el
 404                         host source.', null, null, null, 'HTML');
 405             }
 406             $res = $this->_db_dest->execute($sql, array ($value[0], $id_perfil,
 407                         $id_sistema, $this->_responsable));
 408             if (PEAR::isError($res)) {
 409                 return $res;
 410             }
 411         }
 412     }
 413
 414     /**
 415      * Verifica si existe en el host destino un sistema con igual nombre.
 416      *
 417      * @return mixed
 418      * @access protected
 419      */
 420     function _verificarExisteSistema() {
 421         $sql = "
 422             SELECT count(*) AS cuenta
 423             FROM   samurai.sistema
 424             WHERE  nombre_sistema = ".
 425             $this->_db_dest->quote($this->_sistema->getNombre());
 426         $res = $this->_db_dest->getCol($sql);
 427         if (PEAR::isError($res)) {
 428             return $res;
 429         }
 430         elseif (array_shift($res)) {
 431             return new PEAR_Error ('El sistema ya existe en el host
 432                     seleccionado.', null, null, null, 'HTML');
 433         }
 434     }
 435
 436     /**
 437      * Realiza la conexion con el host destino
 438      *
 439      * @param string $db_host Identificador del servidor MySQL.
 440      * @param string $db_user Identificador del usuario MySQL con permisos en la
 441      *                        base samurai en el host ingresado.
 442      * @param string $db_pass Clave del usuario MySQL.
 443      *
 444      * @return mixed
 445      * @access protected
 446      */
 447     function _dbDestino($db_host, $db_user, $db_pass) {
 448         return  DB::connect(
 449                 "mysql://$db_user:$db_pass@$db_host/samurai"
 450                 ,true
 451                 );
 452     }
 453
 454     /**
 455      * Constructor.
 456      *
 457      * @param DB &$db_source Conexion a la base de datos.
 458      * @param string $db_host Identificador del servidor MySQL.
 459      * @param string $db_user Identificador del usuario MySQL con permisos en la
 460      *                        base samurai en el host ingresado.
 461      * @param string $db_pass Clave del usuario MySQL.
 462      * @param string $responsable Login del responsable de la migracion.
 463      *
 464      * @return void
 465      * @access public
 466      */
 467     function SAMURAI_Migrar(&$db_source, $db_host, $db_user, $db_pass,
 468             $responsable) {
 469         $this->_db_source =& $db_source;
 470         $this->_responsable = $responsable;
 471         //Armo la conexion con el host destino
 472         $this->_db_dest =& $this->_dbDestino($db_host, $db_user, $db_pass);
 473         if (PEAR::isError($this->_db_dest)) {
 474             trigger_error('Error: ' . $this->_db_dest->getMessage() . "\n", E_USER_ERROR);
 475         }
 476     }
 477
 478     /**
 479      * Se encarga de migrar el sistema, que se selecciono, completo (permisos,
 480      * sistema, perfiles, usuarios) al destino ingresado.
 481      *
 482      * @param int $id_sistema Identificador del sistema.
 483      *
 484      * @return mixed
 485      * @access public
 486      */
 487     function migrarSistema($id_sistema) {
 488
 489         //Lockear las tablas en el host source para escritura con la sentencia
 490         //sql lock
 491         $this->_sistema =& new SAMURAI_Sistema($this->_db_source, $id_sistema);
 492
 493         //Verifico si existe el sistema.
 494         $res = $this->_verificarExisteSistema();
 495         if (PEAR::isError($res)) {
 496             return $res;
 497         }
 498         //Migro los permisos.
 499         $permisos = $this->_migrarPermisos();
 500         if (PEAR::isError($permisos)) {
 501             return $permisos;
 502         }
 503         //Migro el sistema.
 504         $sistema = $this->_migrarSistema();
 505         if (PEAR::isError($sistema)) {
 506             return $sistema;
 507         }
 508         //Migro los perfiles.
 509         $perfiles = $this->_migrarPerfiles();
 510         if (PEAR::isError($perfiles)) {
 511             return $perfiles;
 512         }
 513         //Migro los usuarios.
 514         $usuarios = $this->_migrarUsuarios();
 515         if (PEAR::isError($usuarios)) {
 516             return $usuarios;
 517         }
 518         //Migro las relaciones
 519         $relaciones = $this->_migrarRelaciones($sistema, $permisos, $perfiles,
 520                 $usuarios);
 521         if (PEAR::isError($relaciones)) {
 522             return $relaciones;
 523         }
 524         //Deslockear las tablas en el host source para escritura con la sentencia
 525         //sql lock
 526     }
 527 }
 528 ?>