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      * Los datos a pasar son:
  63      *  Obligatorios
  64      *   script     : Path completo para el require_once.
  65      *   id_sistema : Identificador del sistema al que pertenece .
  66      *   descripcion: Es lo que permite al usuario identificar al proecso.
  67      *   owner      : Login@Organismo de la persona responsable del proceso.
  68      *
  69      *  Opcionales
  70      *   destinos   : Login@Organismo separado por comas de aquellos usuarios
  71      *                que deben poder ver los resultados del proceso.
  72      *   prioridad  : Indica la prioridad del proceso.
  73      *   notificar  : Indica si hay que notificar al owner y a los destinos
  74      *                cuando finalize el proceso.
  75      *   resultado  : En caso que el proceso genere archivos resultado, se debe
  76      *                indicar aqui el nombre del archivo que deben visualizar
  77      *                los usuarios.
  78      *
  79      * @param  DB $db Conexion a la base de datos.
  80      * @param  mixed $datos Datos necesarios del proceso.
  81      *
  82      * @return mixed
  83      * @access public
  84      */
  85     function agregarProceso($db, $datos) {
  86         //XXX Dentro de los datos puede estar el tiempo estimado de ejecucion
  87         //del proceso. Esta informacion podria ser utilizada en futuras
  88         //versiones para asignar servidores.
  89
  90         //Si no es un array
  91         if (is_object($datos) && is_a ($datos, 'YATTA_ProcesoDB')) {
  92             $datos = $datos->obtenerDatos();
  93         }
  94         elseif (!is_array($datos)) {
  95             return new PEAR_Error ("Error con los datos pasados. El segundo".
  96                     " parametro debe ser un array asociativo o una instancia".
  97                     " del objeto YATTA_ProcesoDB.");
  98         }
  99         $res = $this->_obtenerServidor($db);
 100
 101         if (DB::isError($res)) {
 102             return $res;
 103         }
 104         $datos['server'] = $res;
 105         $datos['fecha'] = date('Y-m-d');
 106         $res = $db->autoExecute('yatta.procesos', $datos, DB_AUTOQUERY_INSERT);
 107         if (DB::isError($res)) {
 108             return $res;
 109         }
 110         $SERVER =& new YATTA_Servidor;
 111         return $SERVER->agregarProceso($db, $datos['server']);
 112     }
 113
 114     /**
 115      * Obtiene los procesos de un usuario.
 116      *
 117      * @param DB $db Conexion a la base de datos.
 118      * @param string $owner Usuario duenio de los procesos.
 119      * @param int $id Identificador del proceso a buscar
 120      *
 121      * @return mixed
 122      * @access public
 123      */
 124     function obtenerProcesosUsuario($db, $owner, $id = null) {
 125         $proceso =& new YATTA_ProcesoDB;
 126         $proceso->owner = $owner;
 127         if (@$id) {
 128             $proceso->id = $id;
 129             $res = $proceso->buscar($db, MECON_DBO_AND, ' id ASC');
 130             $res = $proceso->cargar($res);
 131             return $proceso;
 132         }
 133         else {
 134             return $proceso->buscar($db, MECON_DBO_AND, ' id ASC');
 135         }
 136     }
 137
 138     /**
 139      * Actualiza los datos de un proceso al terminar.
 140      *
 141      * @param DB $db Conexion a la base de datos.
 142      * @param int $id_proceso Identificador del proceso.
 143      * @param int $id_server Identificador del Servidor.
 144      * @param int $status Identificador del estado de finalizacion.
 145      * @param string $nota Nota de error o similar.
 146      * @param string $archivo Nombre del archivo temporal que esta en el fs.
 147      * @param int $notificar Indica si hay que notificar al owner.
 148      *
 149      * @return mixed
 150      * @access public
 151      */
 152     function terminarProceso($db, $id_proceso, $id_server, $status, $nota =
 153             null, $archivo = null, $notificar = 0) {
 154
 155         //Actualizo la base procesos
 156         $sql = 'UPDATE yatta.procesos SET status = '. $status;
 157         if (@$nota) {
 158             $sql.= ', nota = '. $nota;
 159         }
 160         if (@$archivo) {
 161             $sql.= ', archivo = '. $archivo;
 162         }
 163         if (@$notificar) {
 164             $sql.= ', notificar = '. $notificar;
 165         }
 166         $sql.= ' WHERE id = '. $id_proceso;
 167         $res = $db->query($sql);
 168         if (DB::isError($res)) {
 169             return $res;
 170         }
 171
 172         //NOTIFICO
 173         if (@$notificar) {
 174             $this->_emailUsuario ($db, $id_proceso, $status, $nota, $archivo);
 175         }
 176
 177         //COPIO EL ARCHIVO
 178         if (@$archivo) {
 179             $arch = basename ($archivo);
 180             rename ($archivo, PATH_TACHO.$arch);
 181         }
 182
 183         //Actualizo los servidores
 184         $SERVER =& new YATTA_Servidor;
 185         return $SERVER->quitarProceso($db, $id_server);
 186     }
 187
 188     /**
 189      * Busca un proceso en cola para el servidor
 190      *
 191      * @param DB $db Conexion a la base de datos.
 192      * @param int $id Identificador del servidor.
 193      *
 194      * @return mixed
 195      * @access public
 196      */
 197     function obtenerNuevoProceso($db, $id) {
 198         $res = $db->query('SELECT p.id AS id, p.script AS script
 199                 FROM yatta.procesos AS p
 200                 WHERE p.server = '.$id.' AND status = 0
 201                 ORDER BY p.prioridad, p.id');
 202         // Si hay error lo devuelve.
 203         if (DB::isError($res)) {
 204             return $res;
 205         }
 206         return $res->fetchRow(DB_FETCHMODE_ASSOC);
 207     }
 208
 209     /**
 210      * Busca si un proceso que se esta ejecutando tiene pedido de cancelacion.
 211      *
 212      * @param DB $db Conexion a la base de datos.
 213      * @param int $id Identificador del proceso.
 214      *
 215      * @return mixed
 216      * @access public
 217      */
 218     function abortar($db, $id) {
 219         $res = $db->query('SELECT count(*) AS cuenta
 220                 FROM yatta.procesos
 221                 WHERE id = '.$id.' AND status = 5');
 222         // Si hay error lo devuelve.
 223         if (DB::isError($res)) {
 224             return $res;
 225         }
 226         $res = $res->fetchRow(DB_FETCHMODE_ASSOC);
 227         return  $res['cuenta'];
 228     }
 229
 230     /**
 231      * Envia el email al usuario informandole la finalizacion de uno de sus
 232      * procesos.
 233      *
 234      * @param DB $db Conexion a la base de datos.
 235      * @param int $id_proceso Identificador del proceso.
 236      * @param int $status Identificador del estado de finalizacion.
 237      * @param string $nota Nota de error o similar.
 238      * @param string $archivo Nombre del archivo temporal que esta en el fs.
 239      *
 240      * @return void
 241      * @access private
 242      */
 243     function _emailUsuario($db, $id_proceso, $status, $nota = null, $archivo = null) {
 244         $res = $db->query(
 245                 "SELECT p.descripcion AS descripcion, p.owner AS owner, ".
 246                 "p.destinos AS destinos, p.resultado AS resultado, ".
 247                 "p.estado AS estado, p.nota AS nota ".
 248                 "FROM yatta.procesos AS p".
 249                 "WHERE p.id = ". $id_proceso);
 250         if (DB::isError($res)) {
 251             return $res;
 252         }
 253         $res = $res->fetchRow(DB_FETCHMODE_ASSOC);
 254
 255 //@FIXME El email se lo envio al owner y a los destinos, o al owner solamente?
 256
 257         $dest = split (',', @$res['destinos']);
 258         $to = $owner.'.gov.ar';
 259         foreach ($dest as $d) {
 260             $to = $to . ", $d.gov.ar";
 261         }
 262         $headers = "From: Intranet - YATTA <intranet2@mecon.gov.ar>\r\n";
 263         $subject = "INTRANET - YATTA - Proceso Finalizado";
 264
 265         $body = "El proceso {$res['descripcion']} ha finalizado ";
 266
 267         switch ($status) {
 268             case 2:
 269                 $body .= "con éxito.\n";
 270                 break;
 271             case 3:
 272                 $body .= "con errores.\n";
 273                 if ($nota) {
 274                     $body .= "Motivo:\n$nota\n";
 275                 }
 276                 break;
 277             case 4:
 278                 $body .= "porque se abortó su ejecución.\n";
 279                 if ($nota) {
 280                     $body .= "Motivo:\n$nota\n";
 281                 }
 282                 break;
 283         }
 284
 285         if ($archivo) {
 286             $body .= "Usted puede obtener el archivo resultado del proceso\n".
 287                 "en la seccion Archivos del sistema YATTA.\n".
 288                 "Recuerde que este archivo puede ser borrado sin previo aviso\n".
 289                 "por tres motivos:\n".
 290                 "\t1- El archivo supera la antigüedad máxima establecida.\n".
 291                 "\t2- Se supero la capacidad máxima de información permitida\n".
 292                 "\t   por usuario.\n".
 293                 "\t3- Decisión administrativa por mantenimiento de los servidores.\n";
 294         }
 295
 296
 297
 298         $body .="\n\n\n".
 299             "************************************************************\n".
 300             "Este es un mensaje generado automaticamente por MECON_YATTA.\n".
 301             "Por favor no responder a esta direccion de e-mail.\n".
 302             "************************************************************\n";
 303
 304         mail($to, $subject, $body, $headers);
 305     }
 306
 307     /**
 308      * Verifica si un usuario tiene alguna informacion en la base de yatta para
 309      * mostrarle el icono en la lista de sistemas de la intranet.
 310      *
 311      * @param DB $db Conexion a la base de datos.
 312      * @param string $login Usuario que se esta verificando
 313      *
 314      * @return bool
 315      * @access public
 316      * @static
 317      */
 318     function visible($DB, $login) {
 319         $res = $db->query('SELECT count (p.id) AS id FROM yatta.procesos AS p'.
 320             ' WHERE (p.owner LIKE \'%'. $login .'%\') OR'.
 321             ' (p.destinos LIKE \'%'. $login .'%\')');
 322
 323         if (DB::isError($res)) {
 324             return $res;
 325         }
 326         $res = $res->fetchRow(DB_FETCHMODE_ASSOC);
 327
 328         return $res['id'];
 329     }
 330
 331     /**
 332      * Busca los usuarios que tienen al menos una entrada en el mysql como
 333      * owners.
 334      *
 335      * @param DB $db Conexion a la base de datos.
 336      *
 337      * @return mixed
 338      * @access public
 339      */
 340     function obtenerListaOwners($db) {
 341         return $db->query('SELECT DISTINCT p.owner AS owner
 342                 FROM yatta.procesos As p');
 343     }
 344
 345     /**
 346      * Obtiene las cuotas especiales de los usuarios.
 347      *
 348      * @param DB $db Conexion a la base de datos.
 349      *
 350      * @return mixed
 351      * @access public
 352      */
 353     function obtenerListaCuotas($db) {
 354         return $db->query('SELECT login, cuota
 355                 FROM yatta.cuotas');
 356     }
 357 }
 358 ?>