lib/YATTA/Controlador.php

   1 <?php /* vim: set binary expandtab tabstop=4 shiftwidth=4 textwidth=80:
   2 -------------------------------------------------------------------------------
   3                              Ministerio de Economía
   4                                     YATTA!
   5 -------------------------------------------------------------------------------
   6 This file is part of YATTA!.
   7
   8 YATTA! is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2 of the License, or (at your option)
  11 any later version.
  12
  13 YATTA! is distributed in the hope that it will be useful, but WITHOUT
  14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License; if not,
  18 write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19 Boston, MA  02111-1307  USA
  20 -------------------------------------------------------------------------------
  21 Creado: vie ene  9 16:28:04 ART 2004
  22 Autor:  Martin Marrese <mmarre@mecon.gov.ar>
  23 -------------------------------------------------------------------------------
  24 $Id$
  25 -----------------------------------------------------------------------------*/
  26
  27 require_once 'YATTA/Proceso.php';
  28 require_once 'YATTA/ProcesoDB.php';
  29 require_once 'YATTA/Servidor.php';
  30
  31 define ('PATH_TACHO', '/var/www/sistemas/yatta/tacho/');
  32
  33 /**
  34  * Clase para el manejo centralizado de toda la informacion de YATTA.
  35  *
  36  * @access public
  37  */
  38 class YATTA_Controlador {
  39
  40     /**
  41      * Obtiene el nombre del servidor al cual asignar un nuevo proceso.
  42      *
  43      * @param DB $db Conexion a la base de datos.
  44      *
  45      * @return mixed
  46      * @access private
  47      */
  48     function _obtenerServidor($db) {
  49         $res = $db->query('SELECT s.id, s.escala * s.procesos AS ponderacion
  50             FROM yatta.servidores AS s
  51             ORDER BY ponderacion ASC, s.escala DESC');
  52         // Si hay error lo devuelve.
  53         if (DB::isError($res)) {
  54             return $res;
  55         }
  56         $res = $res->fetchRow(DB_FETCHMODE_ASSOC);
  57         return  $res['id'];
  58     }
  59
  60     /**
  61      * Agrega un proceso a la base de datos
  62      * Recibe un array asociativo con:
  63      *  Obligatorios
  64      *   script     : Path completo para el require_once.
  65      *   id_sistema : Identificador del sistema al que pertenece. (Es el id que
  66      *                asigna SAMURAI)
  67      *   descripcion: Es lo que permite al usuario identificar al proceso.
  68      *   owner      : Login@Organismo de la persona responsable del proceso.
  69      *
  70      *  Opcionales
  71      *   destinos   : Login@Organismo separado por comas de aquellos usuarios
  72      *                que deben poder ver los resultados del proceso.
  73      *   prioridad  : Indica la prioridad del proceso.
  74      *   notificar  : Indica si hay que notificar al owner y a los destinos
  75      *                cuando finalize el proceso.
  76      *   resultado  : En caso que el proceso genere archivos resultado, se debe
  77      *                indicar aqui el nombre del archivo que deben visualizar
  78      *                los usuarios.
  79      *   parametros : Parametros que hay que pasarle al metodo run del script.
  80      *
  81      * @param  DB $db Conexion a la base de datos.
  82      * @param  mixed $datos Datos necesarios del proceso.
  83      *
  84      * @return mixed
  85      * @access public
  86      */
  87     function agregarProceso($db, $datos) {
  88         //XXX Dentro de los datos puede estar el tiempo estimado de ejecucion
  89         //del proceso. Esta informacion podria ser utilizada en futuras
  90         //versiones para asignar servidores.
  91
  92         //Si no es un array
  93         if (is_object($datos) && is_a ($datos, 'YATTA_ProcesoDB')) {
  94             $datos = $datos->obtenerDatos();
  95         }
  96         elseif (!is_array($datos)) {
  97             return new PEAR_Error ("Error con los datos pasados. El segundo".
  98                     " parametro debe ser un array asociativo o una instancia".
  99                     " del objeto YATTA_ProcesoDB.");
 100         }
 101         $res = $this->_obtenerServidor($db);
 102
 103         //Serializo los parametros
 104         if (@$datos['parametros']) {
 105             $datos['parametros'] = serialize($datos['parametros']);
 106         }
 107
 108         if (DB::isError($res)) {
 109             return $res;
 110         }
 111         $datos['server'] = $res;
 112         $datos['fecha'] = date('Y-m-d');
 113         $res = $db->autoExecute('yatta.procesos', $datos, DB_AUTOQUERY_INSERT);
 114         if (DB::isError($res)) {
 115             return $res;
 116         }
 117         $SERVER =& new YATTA_Servidor;
 118         return $SERVER->agregarProceso($db, $datos['server']);
 119     }
 120
 121     /**
 122      * Obtiene los procesos de un usuario.
 123      *
 124      * @param DB $db Conexion a la base de datos.
 125      * @param string $owner Usuario duenio de los procesos.
 126      * @param int $id Identificador del proceso a buscar
 127      *
 128      * @return mixed
 129      * @access public
 130      */
 131     function obtenerProcesosUsuario($db, $owner, $id = null) {
 132         $proceso =& new YATTA_ProcesoDB;
 133         $proceso->owner = $owner;
 134         if (@$id) {
 135             $proceso->id = $id;
 136             $res = $proceso->buscar($db, MECON_DBO_AND, ' id ASC');
 137             $res = $proceso->cargar($res);
 138             return $proceso;
 139         }
 140         else {
 141             return $proceso->buscar($db, MECON_DBO_AND, ' id ASC');
 142         }
 143     }
 144
 145     /**
 146      * Actualiza los datos de un proceso al terminar.
 147      *
 148      * @param DB $db Conexion a la base de datos.
 149      * @param int $id_proceso Identificador del proceso.
 150      * @param int $id_server Identificador del Servidor.
 151      * @param int $status Identificador del estado de finalizacion.
 152      * @param string $nota Nota de error o similar.
 153      * @param string $archivo Nombre del archivo temporal que esta en el fs.
 154      * @param int $notificar Indica si hay que notificar al owner.
 155      *
 156      * @return mixed
 157      * @access public
 158      */
 159     function terminarProceso($db, $id_proceso, $id_server, $status, $nota =
 160             null, $archivo = null, $notificar = 0) {
 161
 162         //NOTIFICO
 163         if (@$notificar) {
 164             $this->_emailUsuario ($db, $id_proceso, $status, $nota, $archivo);
 165         }
 166
 167         //COPIO EL ARCHIVO
 168         if (@$archivo) {
 169             $arch = basename ($archivo);
 170             rename ($archivo, PATH_TACHO.$arch);
 171         }
 172
 173         //ACTUALIZO LA BASE PROCESOS
 174         $sql = 'UPDATE yatta.procesos SET status = '.
 175             $db->quoteSmart($status);
 176         if (@$nota) {
 177             $sql.= ', nota = '. $db->quoteSmart($nota);
 178         }
 179         if (@$archivo) {
 180             $sql.= ', archivo = '. $db->quoteSmart(PATH_TACHO.$arch);
 181         }
 182         if (@$notificar) {
 183             $sql.= ', notificar = '. $db->quoteSmart($notificar);
 184         }
 185         $sql.= ' WHERE id = '. $db->quoteSmart($id_proceso);
 186
 187         $res = $db->query($sql);
 188         if (DB::isError($res)) {
 189             return $res;
 190         }
 191
 192
 193         //Actualizo los servidores
 194         $SERVER =& new YATTA_Servidor;
 195         return $SERVER->quitarProceso($db, $id_server);
 196     }
 197
 198     /**
 199      * Busca un proceso en cola para el servidor
 200      *
 201      * @param DB $db Conexion a la base de datos.
 202      * @param int $id Identificador del servidor.
 203      *
 204      * @return mixed
 205      * @access public
 206      */
 207     function obtenerNuevoProceso($db, $id) {
 208         $res = $db->query('SELECT p.id AS id, p.script AS script, p.parametros
 209                 AS parametros
 210                 FROM yatta.procesos AS p
 211                 WHERE p.server = '.$id.' AND status = 0
 212                 ORDER BY p.prioridad, p.id');
 213         // Si hay error lo devuelve.
 214         if (DB::isError($res)) {
 215             return $res;
 216         }
 217         return $res->fetchRow(DB_FETCHMODE_ASSOC);
 218     }
 219
 220     /**
 221      * Busca si un proceso que se esta ejecutando tiene pedido de cancelacion.
 222      *
 223      * @param DB $db Conexion a la base de datos.
 224      * @param int $id Identificador del proceso.
 225      *
 226      * @return mixed
 227      * @access public
 228      */
 229     function abortar($db, $id) {
 230         $res = $db->query('SELECT count(*) AS cuenta
 231                 FROM yatta.procesos
 232                 WHERE id = '.$id.' AND status = 5');
 233         // Si hay error lo devuelve.
 234         if (DB::isError($res)) {
 235             return $res;
 236         }
 237         $res = $res->fetchRow(DB_FETCHMODE_ASSOC);
 238         return  $res['cuenta'];
 239     }
 240
 241     /**
 242      * Envia el email al usuario informandole la finalizacion de uno de sus
 243      * procesos.
 244      *
 245      * @param DB $db Conexion a la base de datos.
 246      * @param int $id_proceso Identificador del proceso.
 247      * @param int $status Identificador del estado de finalizacion.
 248      * @param string $nota Nota de error o similar.
 249      * @param string $archivo Nombre del archivo temporal que esta en el fs.
 250      *
 251      * @return void
 252      * @access private
 253      */
 254     function _emailUsuario($db, $id_proceso, $status, $nota = null, $archivo = null) {
 255         $res = $db->query(
 256                 "SELECT p.descripcion AS descripcion, p.owner AS owner, ".
 257                 "p.destinos AS destinos, p.resultado AS resultado, ".
 258                 "p.status AS estado, p.nota AS nota ".
 259                 "FROM yatta.procesos AS p ".
 260                 "WHERE p.id = ". $id_proceso);
 261
 262         if (DB::isError($res)) {
 263             return $res;
 264         }
 265         $res = $res->fetchRow(DB_FETCHMODE_ASSOC);
 266
 267
 268 //@FIXME El email se lo envio al owner y a los destinos, o al owner solamente?
 269
 270         $dest = split (',', @$res['destinos']);
 271         $to = $res['owner'].'.gov.ar';
 272         foreach ($dest as $d) {
 273             $to = $to . ", $d.gov.ar";
 274         }
 275         $headers = "From: Intranet - YATTA <intranet2@mecon.gov.ar>\r\n";
 276         $subject = "INTRANET - YATTA - Proceso Finalizado";
 277
 278         $body = "El proceso {$res['descripcion']} ha finalizado ";
 279
 280         switch ($status) {
 281             case 2:
 282                 $body .= "con éxito.\n";
 283                 break;
 284             case 3:
 285                 $body .= "con errores.\n";
 286                 if ($nota) {
 287                     $body .= "Motivo:\n$nota\n";
 288                 }
 289                 break;
 290             case 4:
 291                 $body .= "porque se abortó su ejecución.\n";
 292                 if ($nota) {
 293                     $body .= "Motivo:\n$nota\n";
 294                 }
 295                 break;
 296         }
 297
 298         if ($archivo) {
 299             $body .= "Usted puede obtener el archivo resultado del proceso\n".
 300                 "en la seccion Archivos del sistema YATTA.\n".
 301                 "Recuerde que este archivo puede ser borrado sin previo aviso\n".
 302                 "por tres motivos:\n".
 303                 "1- El archivo supera la antigüedad máxima establecida.\n".
 304                 "2- Se supero la capacidad máxima de información permitida\n".
 305                 "   por usuario.\n".
 306                 "3- Decisión administrativa por mantenimiento de los servidores.\n";
 307         }
 308
 309
 310
 311         $body .="\n\n\n".
 312             "************************************************************\n".
 313             "Este es un mensaje generado automaticamente por MECON_YATTA.\n".
 314             "Por favor no responder a esta direccion de e-mail.\n".
 315             "************************************************************\n";
 316
 317         mail($to, $subject, $body, $headers);
 318     }
 319
 320     /**
 321      * Verifica si un usuario tiene alguna informacion en la base de yatta para
 322      * mostrarle el icono en la lista de sistemas de la intranet.
 323      *
 324      * @param DB $db Conexion a la base de datos.
 325      * @param string $login Usuario que se esta verificando
 326      *
 327      * @return bool
 328      * @access public
 329      * @static
 330      */
 331     function visible($DB, $login) {
 332         $res = $db->query('SELECT count (p.id) AS id FROM yatta.procesos AS p'.
 333             ' WHERE (p.owner LIKE \'%'. $login .'%\') OR'.
 334             ' (p.destinos LIKE \'%'. $login .'%\')');
 335
 336         if (DB::isError($res)) {
 337             return $res;
 338         }
 339         $res = $res->fetchRow(DB_FETCHMODE_ASSOC);
 340
 341         return $res['id'];
 342     }
 343
 344     /**
 345      * Busca los usuarios que tienen al menos una entrada en el mysql como
 346      * owners.
 347      *
 348      * @param DB $db Conexion a la base de datos.
 349      *
 350      * @return mixed
 351      * @access public
 352      */
 353     function obtenerListaOwners($db) {
 354         return $db->query('SELECT DISTINCT p.owner AS owner
 355                 FROM yatta.procesos As p');
 356     }
 357
 358     /**
 359      * Obtiene las cuotas especiales de los usuarios.
 360      *
 361      * @param DB $db Conexion a la base de datos.
 362      *
 363      * @return mixed
 364      * @access public
 365      */
 366     function obtenerListaCuotas($db) {
 367         return $db->query('SELECT login, cuota
 368                 FROM yatta.cuotas');
 369     }
 370 }
 371 ?>