Sei sulla pagina 1di 33

/*****************************************************************************

Programa: CARC00100.pc
Este programa se encarga de ejecutar cada uno de los programas
que esten pendientes de ejecucion, segun los procesos que estan
registrados en la tabla de ordenes de procesos ORDENEENPROCESO

Por cada orden a ejecutar se verifica que no exista una orden


ejecutandose por otra cola, (ORDENEJECUTANDO), y
sea critica con la orden a ejecutar, ver ordenes criticas en
ORDENCRITICA.

Este programa atiende ordenes de la cola de parametro


*****************************************************************************/

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "sys/stat.h"
#include "float.h"
#define DEFECTO "wide220" /* Para Reportes en report 220 columnas*/

FILE *archivo,*job,*joblog;

/***************************************************************************
Definicion de buffer's de e/s con sql
(declare section)
****************************************************************************/

EXEC SQL BEGIN DECLARE SECTION;


VARCHAR wDIR_OBJ_PL[62];
VARCHAR wDIR_OBJ_PROC[62];
VARCHAR wDIR_OBJ_REPO[62];
VARCHAR wDIR_LIS_PL[62];
VARCHAR wDIR_LIS_PROC[62];
VARCHAR wDIR_LIS_REPO[62];
VARCHAR wDIR_LOG_PL[62];
VARCHAR wDIR_LOG_PROC[62];
VARCHAR wDIR_LOG_REPO[62];
VARCHAR wDIR_OBJ_SCRIPT[62];
VARCHAR wDIR_LIS_SCRIPT[62];
VARCHAR wDIR_LOG_SCRIPT[62];
VARCHAR wREPSERVER[61];
VARCHAR wDIR_BASES[61];
VARCHAR wMAQUINA[22];
VARCHAR wDIR_LIS[62];
VARCHAR wTIPO_LIS[3];
int a;
EXEC SQL END DECLARE SECTION;

EXEC SQL BEGIN DECLARE SECTION;


long int wnu_secuencia;
long int wnu_secuencia_rev;
int wcd_orden;
int wcd_orden_rev;
int wcd_sub_orden;
int wcd_sub_orden_rev;
VARCHAR wfe_orden[12];
VARCHAR whr_orden[12];
VARCHAR wfe_hr_orden[31];
VARCHAR wcd_usuario[12];
VARCHAR wde_terminal[12];
VARCHAR wcd_impresora[12];
VARCHAR wCOLA[3];
VARCHAR wst_a_rev[3];
VARCHAR wst_b[3];
VARCHAR wst_c[3];
int wcd_prioridad;
int wnu_copias;
VARCHAR wde_parametros_script[202];
int wparada;
VARCHAR win_modo[2];
VARCHAR wcd_limitador[2];
VARCHAR wparam_1[60];
VARCHAR wparam_2[60];
VARCHAR wparam_3[60];
VARCHAR wparam_4[60];
VARCHAR wparam_5[60];
VARCHAR wparam_6[60];
VARCHAR wparam_7[60];
VARCHAR wparam_8[60];
VARCHAR wparam_9[60];
VARCHAR wparam_10[60];
VARCHAR wparam_11[60];
VARCHAR wparam_12[60];
VARCHAR wparam_13[60];
VARCHAR wparam_14[60];
VARCHAR wparam_15[60];
VARCHAR wparam_16[60];
VARCHAR wparam_17[60];
VARCHAR wdi_destinatario[300];
double wid_proceso;
EXEC SQL END DECLARE SECTION;

/********************************************************************
Buffer de la tabla de relacion orden programa
********************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
VARCHAR wcaob_nm_programa[18];
VARCHAR wnm_programa_rev[18];
int wcaob_cd_orden;
int wcaob_cd_sub_orden;
VARCHAR wcaob_tp_impresion[3];
int wcaob_nu_longitud;
VARCHAR wcaob_in_lenguaje[3];
int wcaob_in_salida;
VARCHAR wcaob_st_programa[3];
VARCHAR wcaob_nm_prelacion[43];
VARCHAR wcaob_nm_pred[62];
VARCHAR wcaob_nm_form[62];
VARCHAR wcaob_nm_suce[62];
VARCHAR wcaob_forma_papel[22];
VARCHAR wcaob_in_modo[2];
int wcaob_in_directa;
VARCHAR wcaob_cd_impresora[12];
VARCHAR w_de_ubicacion[120];

EXEC SQL END DECLARE SECTION;


/*********************************************************************
Declaracion de variables de coneccion con la base de datos
*********************************************************************/
EXEC SQL BEGIN DECLARE SECTION;
VARCHAR wusuario[20];
VARCHAR wclave[20];
int wcada_cd_prioridad;
VARCHAR wUsuario[30];
VARCHAR wClave[30];
VARCHAR USUARIO[40];
VARCHAR PASSWORD[15];
VARCHAR USUARIO1[15];
VARCHAR USUARIOGADS[15];
VARCHAR PASSWORDGADS[15];
VARCHAR wALIAS[20];
VARCHAR wDATABASE[20];
EXEC SQL END DECLARE SECTION;

/********************************************************************
Variables para actualizar tabla de impresion
*********************************************************************/

EXEC SQL BEGIN DECLARE SECTION;


VARCHAR rnm_programa[32];
VARCHAR waux_outfile[32];
VARCHAR rst_programa[3];
int rcd_prioridad;
VARCHAR prg[1000];
VARCHAR dellog[1000];
long int rcaos_longitud;
int paso;
int wpausa;
VARCHAR secuencia[11];
VARCHAR Joblist[120];
VARCHAR wFECHA[23];
VARCHAR wHORA[23];
VARCHAR wTIEMPO_DURACION[23];
VARCHAR wTIEMPO_DURACION_ORDEN[23];
VARCHAR wFECHA_HORA[23];
VARCHAR wFECHA_HORA_FIN[31];
VARCHAR wFECHA_FIN[23];
VARCHAR wHORA_FIN[23];
VARCHAR w_extension[4];
int wHORAJOB;
double wDif_MINUTOS;
double wDif_MINUTOS_ORDEN;
EXEC SQL END DECLARE SECTION;
/*********************************************************************
Variables que funcionan como parametros y para conversion de
number a char
*********************************************************************/
char parametro[20],parametro1[20];
int digitos,argc,procesos,p_c,p_r,p_p,p_s,p_w,t_mal,t_bien,indi;
int F_Revisa_Cola();
int F_Sel_Critica();

/********************************************************************
Declaracion del registro sqlca
*********************************************************************/
EXEC SQL INCLUDE sqlca;

/*********************************************************************
Declaracion de la funcion main del programa
*********************************************************************/

void main(par,argv)
int par;
char *argv[];
{
/********************************************************************
* Conectarse con la base de datos
* VALIDAR MAQUINA Y COLA ANTES DE CONEXION A BD
*********************************************************************/

if (par<2)
{
printf("\nError: Faltan Parametros..... wCOLA = %s wMAQUINA = %s",
argv[1],argv[2]);
exit(1);
}

printf("Inicia la conexion del programa CARC00100 \n");

wCOLA.len = sprintf((char *) wCOLA.arr,"%s",argv[1]);


wCOLA.len = strlen((char *) wCOLA.arr);
wCOLA.arr[wCOLA.len] = '\0';
printf("la cola es %s \n", wCOLA.arr);

printf("maquina es \n", wMAQUINA.arr);

wMAQUINA.len = sprintf((char *) wMAQUINA.arr,"%s",argv[2]);


wMAQUINA.len = strlen((char *) wMAQUINA.arr);
wMAQUINA.arr[wMAQUINA.len] = '\0';

printf("alias es \n", wALIAS.arr);


wALIAS.len = sprintf(wALIAS.arr,"%s",argv[3]);
wALIAS.len = strlen((char *) wALIAS.arr);
wALIAS.arr[wALIAS.len] = '\0';

printf("database es \n", wDATABASE.arr);


wDATABASE.len = sprintf(wDATABASE.arr,"%s",argv[4]);
wDATABASE.len = strlen((char *) wDATABASE.arr);
wDATABASE.arr[wDATABASE.len] = '\0';

printf("Recibe las variables de COLA y MAQUINA /n");

FileConnect();
digitos = 8;
printf("\n antes de selec ambiente \n");
F_Sel_Ambiente();
printf("\n despues de selec ambiente \n");

/*******************************************************************
Inicializar contadores de procesos
********************************************************************/
p_p = 0; p_r = 0; p_c = 0; p_s = 0; p_w = 0; procesos = 0;
t_mal = 0; t_bien = 0;

if (F_Revisa_Cola() != 0)
{
exit(0);
}

/***********************************
Se bloquea la cola
***********************************/
EXEC SQL UPDATE COLA SET ST_COLA = 1
WHERE CD_COLA = :wCOLA;

EXEC SQL COMMIT;

F_Crear_archivo();

printf("\n despues de crear archivo \n");

/********************************************************************
Definicion de cursor para acceso a la tabla de ordenes de proceso
smb 24-06-2015 se agrega lectura de los parametros para el envio de correo
que van a estar en la tabla ordenenproceso
*********************************************************************/
EXEC SQL DECLARE C_ORDEN CURSOR FOR
SELECT NU_SECUENCIA,
CD_ORDEN,
CD_SUBORDEN,
TO_char(FE_ORDEN,'DD-MM-YYYY'),
TO_char(FE_ORDEN,'HH24:MI:SS'),
CD_USUARIO,
NVL(TRIM(CD_IMPRESORA),'NULL'),
1, -- OJO VER LO DE NUMERO DE COPIAS
DECODE(NVL(NU_COPIAS,0),0,1,NU_COPIAS),
CD_PRIORIDAD,
' ',-- OJO VER LA PARTE DE PARAMETROS DE SCRIPT
NVL(TRIM(DE_PARAMETROS_SCRIPT)),' '),
TO_char(FE_ORDEN,'DD-MM-YYYY HH24:MI:SS'),
nvl(IN_MODO,'P'),
nvl(cd_caracter_delimitador,' '),
ID_PROCESO,
nvl(nm_parametro1,'S'), -- para la parte de los web services y correo
nvl(nm_parametro2,''),
nvl(nm_parametro3,''),
nvl(nm_parametro4,''),
nvl(nm_parametro5,''),
nvl(nm_parametro6,''),
nvl(nm_parametro7,''),
nvl(nm_parametro8,''),
nvl(nm_parametro9,''),
nvl(nm_parametro10,''),
nvl(nm_parametro11,''),
nvl(nm_parametro12,''),
nvl(nm_parametro13,''),
nvl(nm_parametro14,''),
nvl(nm_parametro15,''),
nvl(nm_parametro16,''),
nvl(nm_parametro17,''),
nvl(di_destinatario,'')
FROM ORDENENPROCESO
WHERE CD_PRIORIDAD <= :wcada_cd_prioridad
AND ST_B IS NULL
AND ST_C IS NULL
AND CD_COLA = :wCOLA
AND ID_PROCESO IS NOT NULL
ORDER BY CD_PRIORIDAD
,ID_PROCESO
,NU_SECUENCIA;

/***********************************************************************
Declarar cursor para accesar la tabla de operaciones batchs
donde esta la relacion orden de proceso-programa
***********************************************************************/
EXEC SQL DECLARE C_caob_s CURSOR FOR
SELECT NM_PROGRAMA,
DE_PROGRAMA,
IN_LENGUAJE,
NVL(ST_PROGRAMA,1),
NVL(IN_SALIDA,0),
NVL(IN_MODO,'P'),
NVL(TP_IMPRESION,'L'),
NVL(NU_LONGITUD_SALIDA,180),
' ', -- OJO NVL(SCRI_DIALOGO,' '),
' ', -- OJO NVL(SCRI_SUCE,' '),
' ', --OJONVL(FORMA_PAPEL,' '),
TO_char(SYSDATE,'DD-MM-YYYY HH24:MI:SS'),
TO_char(SYSDATE,'DD-MM-YYYY'),
TO_char(SYSDATE,'HH24:MI:SS'),
NVL(IN_IMPRESION_DIRECTA,0),
NVL(CD_IMPRESORA,' ')
FROM ORDENEJECUCION
WHERE CD_ORDEN = :wcd_orden
AND CD_SUBORDEN = :wcd_sub_orden;

/***********************************************************************
Se toma la prioridad de la tabla de prioridades
***********************************************************************/
EXEC SQL SELECT CD_PRIORIDAD
INTO :wcada_cd_prioridad
FROM COLA
WHERE CD_COLA = :wCOLA;

if (sqlca.sqlcode != 0 )
wcada_cd_prioridad = 1;

EXEC SQL OPEN C_ORDEN;


while(1)
{
wpausa=0;
/**********************************************************/
/* Leer las ordenes de proceso */
/**********************************************************/
EXEC SQL FETCH C_ORDEN INTO :wnu_secuencia,
:wcd_orden,
:wcd_sub_orden,
:wfe_orden,
:whr_orden,
:wcd_usuario,
:wcd_impresora,
:wnu_copias,
:wcd_prioridad,
:wde_parametros_script,
:wfe_hr_orden,
win_modo,
wcd_limitador,
wid_proceso,
wparam_1,
wparam_2,
wparam_3,
wparam_4,
wparam_5,
wparam_6,
wparam_7,
wparam_8,
wparam_9,
wparam_10,
wparam_11,
wparam_12,
wparam_13,
wparam_14,
wparam_15,
wparam_16,
wparam_17,
wdi_destinatario;

if (sqlca.sqlcode != 0)
{
printf("\nNo hay procesos en Cola...sqlcode....> %s",sqlca.sqlerrm.sqlerrmc);
break;
}
if (F_Chequea_Cola() == 9) /* Parada de emergencia */
{
wpausa=9;
break;
}
wcd_usuario.arr[wcd_usuario.len] = '\0';
win_modo.arr[win_modo.len] = '\0';
wcd_limitador.arr[wcd_limitador.len] = '\0';
wparam_1.arr[wparam_1.len] = '\0';
wparam_2.arr[wparam_2.len] = '\0';
wparam_3.arr[wparam_3.len] = '\0';
wparam_4.arr[wparam_4.len] = '\0';
wparam_5.arr[wparam_5.len] = '\0';
wparam_6.arr[wparam_6.len] = '\0';
wparam_7.arr[wparam_7.len] = '\0';
wparam_8.arr[wparam_8.len] = '\0';
wparam_9.arr[wparam_9.len] = '\0';
wparam_10.arr[wparam_10.len] = '\0';
wparam_11.arr[wparam_11.len] = '\0';
wparam_12.arr[wparam_12.len] = '\0';
wparam_13.arr[wparam_13.len] = '\0';
wparam_14.arr[wparam_14.len] = '\0';
wparam_15.arr[wparam_15.len] = '\0';
wparam_16.arr[wparam_16.len] = '\0';
wparam_17.arr[wparam_17.len] = '\0';
wdi_destinatario.arr[wdi_destinatario.len] = '\0';
wcd_impresora.arr[wcd_impresora.len] = '\0';
wfe_orden.arr[wfe_orden.len] = '\0';
whr_orden.arr[whr_orden.len] = '\0';
wfe_hr_orden.arr[wfe_hr_orden.len] = '\0';
wde_parametros_script.arr[wde_parametros_script.len] = '\0';

printf("\nSECUENCIA.............> %d",wnu_secuencia);
printf(" Fecha Orden..........> %s\n",wfe_orden.arr);
printf(" Orden................> %4d",wcd_orden);
printf(" Hora Orden...........> %s\n",whr_orden.arr);
printf(" SubOrden.............> %02d",wcd_sub_orden);
printf(" Prioridad............> %d\n",wcd_prioridad);
printf(" Usuario..............> %s\n",wcd_usuario.arr);
printf(" Impresora............> %s",wcd_impresora.arr);
printf(" Copias...............> %d\n",wnu_copias);
printf(" Parametros Script....> %s\n",wde_parametros_script.arr);

{
EXEC SQL OPEN C_caob_s;
/**********************************************************/
/* Leer laa prelacion de la Orden y Sub Orden */
/**********************************************************/
EXEC SQL FETCH C_caob_s INTO :wcaob_nm_programa,
:wcaob_nm_prelacion,
:wcaob_in_lenguaje,
:wcaob_st_programa,
:wcaob_in_salida,
:wcaob_in_modo,
:wcaob_tp_impresion,
:wcaob_nu_longitud,
:wcaob_nm_pred,
:wcaob_nm_suce,
:wcaob_forma_papel,
:wFECHA_HORA,
:wFECHA,
:wHORA,
:wcaob_in_directa,
:wcaob_cd_impresora;

wcaob_nm_programa.arr[wcaob_nm_programa.len] = '\0';
wcaob_nm_prelacion.arr[wcaob_nm_prelacion.len] = '\0';
wcaob_in_lenguaje.arr[wcaob_in_lenguaje.len]= '\0';
wcaob_tp_impresion.arr[wcaob_tp_impresion.len]= '\0';
wcaob_nm_pred.arr[wcaob_nm_pred.len]= '\0';
wcaob_nm_suce.arr[wcaob_nm_suce.len]= '\0';
wcaob_forma_papel.arr[wcaob_forma_papel.len]= '\0';
wFECHA.arr[wFECHA.len] = '\0';
wHORA.arr[wHORA.len] = '\0';
wFECHA_HORA.arr[wFECHA_HORA.len] = '\0';
wcaob_cd_impresora.arr[wcaob_cd_impresora.len] = '\0';

printf(" Programa.............> %s",wcaob_nm_programa.arr);


printf(" Fecha y Hora.........> %s %s\n",wFECHA.arr,wHORA.arr);
printf(" Lenguaje.............> %s",wcaob_in_lenguaje.arr);
printf(" Nombre...............>
%s\n",wcaob_nm_prelacion.arr);
printf(" Status Programa......> %s",wcaob_st_programa.arr);
printf(" Tiene Salida.........> %d\n",wcaob_in_salida);
printf(" Tipo Impresion.......> %s",wcaob_tp_impresion.arr);
printf(" Longitud Reporte.....>
%d\n",wcaob_nu_longitud);
printf(" Script Dialogo.......> %s",wcaob_nm_pred.arr);
printf(" Script Sucesor.......>
%s\n",wcaob_nm_suce.arr);
printf(" Forma Papel..........> %s",wcaob_forma_papel.arr);
printf(" Impresion Directa....> %d\n",wcaob_in_directa);
printf(" Impresora............> %s\n",wcaob_cd_impresora.arr);
fflush(stdout);

if (sqlca.sqlcode != 0)
{
printf("\nNo hay prelacion para esta Orden...sqlcode....>
%s",sqlca.sqlerrm.sqlerrmc);
fflush(stdout);
continue;
}
if (F_Sel_Critica() != 0)
{
printf("Proceso no se ejecuta por ser critico \n");
printf("Esta en ejecucion una orden critica \n");
printf(" Programa ..............> %s \n ",wcaob_nm_programa.arr);
printf(" Usuario ...............> %s \n ",wcd_usuario.arr);
printf(" Nro. Secuencia ........> %d \n",wnu_secuencia);
fflush(stdout);
continue;
}
/*======================================================*/
/* Se verifica si la Orden fue cambiada de cola para */
/* evitar que se ejecute mas de una vez */
/*======================================================*/
EXEC SQL SELECT NU_SECUENCIA,
CD_ORDEN,
CD_SUBORDEN,
CD_COLA
INTO :wnu_secuencia_rev,
:wcd_orden_rev,
:wcd_sub_orden_rev,
:wst_a_rev
FROM ORDENENPROCESO
WHERE NU_SECUENCIA = :wnu_secuencia;

wst_a_rev.arr[wst_a_rev.len] = '\0';

if (sqlca.sqlcode == 0)
{
if (strcmp((char *) wst_a_rev.arr,(char *) wCOLA.arr) != 0)
{
printf("\nNo se ejecuta SECUENCIA %d ORDEN %d SUBORDEN %d cambio de COLA %s
a COLA %s\n",wnu_secuencia,wcd_orden,wcd_sub_orden,wCOLA.arr,wst_a_rev.arr);
fflush(stdout);
continue;
}
}
else
{
printf("\nNo se ejecuta SECUENCIA %d ORDEN %d SUBORDEN %d de la COLA %s ya
no existe en ORDENES DE
PROCESOS\n",wnu_secuencia,wcd_orden,wcd_sub_orden,wCOLA.arr);
fflush(stdout);
continue;
}
if (strcmp((char *) wcaob_st_programa.arr,"S") == 0)
{
printf("\nSubOrden %02d Suspendida %s No se
Ejecuta\n",wcd_sub_orden,wcaob_st_programa.arr);
F_Del_CAOS(); /* Borrar Orden suspendida */
argc=0;
}
else
{ /* Orden Activa */
F_Sel_compara();
procesos++;

/***************************************************************/
/* Si el indicador de lenguaje regresa en '*' no se ejecuta */
/* el proceso y se actualizan los status b y c en S y M res- */
/* pectivamente en ORDENENEJECUCION. Si no regresa en '*' */
/* y el lenguaje no existe tambien se actualizan los status */
/***************************************************************/

if (strcmp((char *) wcaob_in_lenguaje.arr,"C")==0)
{
p_c++;
F_Upd_EJECUCION();
F_Ins_EJECUCION();
EXEC SQL COMMIT;
F_Ins_lengc();
if ( argc != 0 )
{
F_Upd_CAOS(); /* Actualizar st_b = 'S' , st_c = 'M' */
F_Del_EJECUCION();
}
else
{
if (wcaob_in_salida == 1)
{
strcpy((char *) wDIR_LIS.arr,(char *) wDIR_LIS_PROC.arr);
/* wDIR_LIS.arr[wDIR_LIS.len] = '\0';*/
F_Upd_impresiones(); /* Actualizar tabla de list */
}
F_Upd_actualiza(); /* Borrar Orden */
}
}
else
if (strcmp((char *) wcaob_in_lenguaje.arr,"P")==0)
{
p_p++;
F_Upd_EJECUCION();
F_Ins_EJECUCION();
EXEC SQL COMMIT;
F_Ins_plsql();
if ( argc != 0 )
{
F_Upd_CAOS(); /* Actualizar st_b = 'S' , st_c = 'M' */
F_Del_EJECUCION();
}
else
{
if ( wcaob_in_salida==1)
{
strcpy((char *) wDIR_LIS.arr,(char *) wDIR_LIS_PL.arr);
/* wDIR_LIS.arr[wDIR_LIS.len] = '\0';*/
F_Upd_impresiones(); /* Actualizar tabla de list */
}
F_Upd_actualiza(); /* Borrar Orden */
}
}
else
if (strcmp((char *) wcaob_in_lenguaje.arr,"R")==0)
{
p_r++;
F_Upd_EJECUCION();
F_Ins_EJECUCION();
EXEC SQL COMMIT;
F_Ins_report();
if ( argc != 0 )
{
F_Upd_CAOS(); /* Actualizar st_b = 'S' , st_c = 'M' */
F_Del_EJECUCION();
}
else
{
/* solo se inserta en impresion si no es directa */
if (wcaob_in_salida == 1 && wcaob_in_directa == 0)
{
strcpy((char *) wDIR_LIS.arr,(char *) wDIR_LIS_REPO.arr);
/* wDIR_LIS.arr[wDIR_LIS.len] = '\0';*/
printf("\n dir_rep %s \n", wDIR_LIS.arr);
F_Upd_impresiones(); /* Actualizar tabla de list */
}
F_Upd_actualiza(); /* Borrar Orden */
}
}
else
if (strcmp((char *) wcaob_in_lenguaje.arr,"W")==0)
{
p_w++;
F_Upd_EJECUCION();
F_Ins_EJECUCION();
EXEC SQL COMMIT;
F_Ins_webservice();
if ( argc != 0 )
{
F_Upd_CAOS(); /* Actualizar st_b = 'S' , st_c = 'M' */
F_Del_EJECUCION();
}
else
{
if (wcaob_in_salida==1)
{
strcpy((char *) wDIR_LIS.arr,(char *) wDIR_LIS_REPO.arr);
/* wDIR_LIS.arr[wDIR_LIS.len] = '\0';*/
printf("\n dir_rep %s \n", wDIR_LIS.arr);
F_Upd_impresiones(); /* Actualizar tabla de list */
}
F_Upd_actualiza(); /* Borrar Orden */
}
}
else
if (strcmp((char *) wcaob_in_lenguaje.arr,"A")==0)
{
p_w++;
F_Upd_EJECUCION();
F_Ins_EJECUCION();
EXEC SQL COMMIT;
F_Ins_calendario();
if ( argc != 0 )
{
F_Upd_CAOS(); /* Actualizar st_b = 'S' , st_c = 'M' */
F_Del_EJECUCION();
}
else
{
if (wcaob_in_salida==1)
{
strcpy((char *) wDIR_LIS.arr,(char *) wDIR_LIS_REPO.arr);
/* wDIR_LIS.arr[wDIR_LIS.len] = '\0';*/
printf("\n dir_rep %s \n", wDIR_LIS.arr);
F_Upd_impresiones(); /* Actualizar tabla de list */
}
F_Upd_actualiza(); /* Borrar Orden */
}
}
else
if (strcmp((char *) wcaob_in_lenguaje.arr,"S")==0)
{
p_s++;
F_Upd_EJECUCION();
F_Ins_EJECUCION();
EXEC SQL COMMIT;
F_Ins_script();
if ( argc != 0 )
{
F_Upd_CAOS(); /* Actualizar st_b = 'S' , st_c = 'M' */
F_Del_EJECUCION();
}
else
{
if (wcaob_in_salida==1)
{
strcpy((char *) wDIR_LIS.arr,(char *) wDIR_LIS_SCRIPT.arr);
/* wDIR_LIS.arr[wDIR_LIS.len] = '\0';*/
F_Upd_impresiones(); /* Actualizar tabla de list */
}
F_Upd_actualiza(); /* Borrar Orden */
}
}
else
F_Upd_CAOS(); /* Actualizar st_b = 'S' , st_c = 'M' */
} /* fin del if Orden Activa */
} /* fin del no hay orden critica */
printf("\nCODIGO DE RETORNO.....> %d\n",argc);
fflush(stdout);
EXEC SQL CLOSE C_caob_s;
EXEC SQL COMMIT;
} /* fin de ciclo while */
/*********************************************************************
Se eliminan las ordenes que terminaron mal
*********************************************************************/
if (wpausa == 0) /* Solo elimino si no hay una pausa de emergencia */
{
EXEC SQL DELETE FROM ORDENENPROCESO
WHERE CD_COLA = :wCOLA
AND ST_B = 'S'
AND ST_C = 'M';
}
EXEC SQL COMMIT;
/*********************************************************************
Se libera la cola
*********************************************************************/
EXEC SQL UPDATE COLA
SET ST_COLA = 0
WHERE CD_COLA = :wCOLA
AND ST_COLA = 1;

EXEC SQL COMMIT;


EXEC SQL CLOSE C_ORDEN;
EXEC SQL CLOSE C_caob_s;
fclose(job);
fclose(joblog);
EXEC SQL COMMIT WORK RELEASE;
exit(0);
}

/********************************************************************
Funcion de coneccion con la base de datos
********************************************************************/

FileConnect()
{

char PassFileName[200] = "\0";


FILE *ArchivoUserPassword;

strcpy(PassFileName, getenv("PASS_FILE"));
printf( "\n\n ARCHIVO PASSWORD PASS_FILE %s\n",PassFileName);

if ((ArchivoUserPassword = fopen(PassFileName, "rt")) == NULL)


{
printf( "\n\nNO SE PUDO ABRIR ARCHIVO PASSWORD PASS_FILE %s\n",PassFileName);
exit(1);
}

fscanf(ArchivoUserPassword, "%s", wUsuario.arr);


fscanf(ArchivoUserPassword, "%s", wClave.arr);

wUsuario.len = strlen(wUsuario.arr);
wClave.len = strlen(wClave.arr);

EXEC SQL CONNECT :wUsuario IDENTifIED BY :wClave;

if (sqlca.sqlcode != 0) {
printf("\n\nNO SE PUDO CONECTAR: %d Usuario %s\n", sqlca.sqlcode,
wUsuario.arr);
printf("Error: Programa CARC00100 abortado en la connecion SQL\n");
printf("Por favor contacte al ABD. Gracias... \n");
exit(1);
}
}

/*********************************************************************
Funcion que elimina la orden de proceso de la tabla de ordenes y
la crea en la tabla de ordenes ejecutadas
*********************************************************************/
F_Upd_actualiza()
{
/*********************************************************/
/* Agregar la orden en operaciones ejecutadas */
/*********************************************************/
F_Ins_ejecutadas();
F_Del_CAOS();
F_Del_EJECUCION();
}
/*********************************************************/
/* Borrar la orden de la tabla de ordenes de procesos */
/*********************************************************/
F_Ins_ejecutadas()
{
EXEC SQL INSERT INTO ORDENEJECUTADA
(VERSION,
NU_SECUENCIA,
CD_ORDEN ,
CD_SUBORDEN ,
FE_EJECUCION,
CD_USUARIO ,
DI_IP ,
CD_PRIORIDAD ,
CD_COLA ,
ST_B ,
ST_C ,
FE_A ,
FE_B ,
FE_C ,
FE_D ,
FE_E ,
NM_PARAMETRO1,
NM_PARAMETRO2,
NM_PARAMETRO3,
NM_PARAMETRO4,
NM_PARAMETRO5,
NM_PARAMETRO6,
NM_PARAMETRO7,
NM_PARAMETRO8,
NM_PARAMETRO9,
NM_PARAMETRO10,
NM_PARAMETRO11 ,
NM_PARAMETRO12 ,
CD_IMPRESORA ,
FE_INICIO_EJECUCION,
FE_TERMINO_EJECUCION,
NU_TIEMPO_ORDEN ,
NU_TIEMPO_EJECUCION,
IN_MODO,
ID_PROCESO,
IN_ERROR)
SELECT
0,
NU_SECUENCIA,
CD_ORDEN ,
CD_SUBORDEN ,
FE_ORDEN,
CD_USUARIO ,
DI_IP ,
CD_PRIORIDAD ,
CD_COLA ,
ST_B ,
ST_C ,
FE_A ,
FE_B ,
FE_C ,
FE_D ,
FE_E ,
NM_PARAMETRO1,
NM_PARAMETRO2,
NM_PARAMETRO3,
NM_PARAMETRO4,
NM_PARAMETRO5,
NM_PARAMETRO6,
NM_PARAMETRO7,
NM_PARAMETRO8,
NM_PARAMETRO9,
NM_PARAMETRO10,
NM_PARAMETRO11 ,
NM_PARAMETRO12 ,
/*nvl(:wcaob_cd_impresora,CD_IMPRESORA) , */
cd_impresora,
TO_DATE(:wFECHA_HORA,'DD-MM-YYYY HH24:MI:SS'),
TO_DATE(:wFECHA_HORA_FIN,'DD-MM-YYYY HH24:MI:SS'),
:wTIEMPO_DURACION_ORDEN,
:wTIEMPO_DURACION,
NVL(IN_MODO,'P'),
ID_PROCESO,
IN_ERROR
FROM ORDENENPROCESO
WHERE NU_SECUENCIA = :wnu_secuencia;
if (sqlca.sqlcode != 0)
{
printf("\nError insertando en F_Upd_actualiza el sqlcode es
%s\n",sqlca.sqlerrm.sqlerrmc);
}
}

/*********************************************************/
/* Borrar la orden de la tabla de ordenes de procesos */
/*********************************************************/
F_Del_CAOS()
{
EXEC SQL DELETE FROM ORDENENPROCESO
WHERE NU_SECUENCIA = :wnu_secuencia
AND CD_COLA = :wCOLA;
}

/***********************************************************/
/* Funcion para actualizar los estatus B y C con indicador */
/* de actualizacion mal, es decir, S Ejecutado y M Termina */
/* mal respectivamente */
/***********************************************************/
F_Upd_CAOS()
{
EXEC SQL BEGIN DECLARE SECTION;
int f_orden;
int f_error;
EXEC SQL END DECLARE SECTION;

EXEC SQL SELECT MAX(CD_SUBORDEN)


INTO :f_orden
FROM ORDENEJECUCION
WHERE CD_ORDEN = :wcd_orden;

EXEC SQL UPDATE ORDENENPROCESO


SET ST_B = 'S',
ST_C = 'M'
WHERE NU_SECUENCIA = :wnu_secuencia
AND CD_COLA = :wCOLA;

if (sqlca.sqlcode != 0)
{
printf("\nError actualizando ST_B='S' ST_C='M' el sqlcode es %s
F_Upd_CAOS\n",sqlca.sqlerrm.sqlerrmc);
}

/* Si NO EXISTE UNA SUBORDEN MARCADA CON ERROR SE MARCA */


EXEC SQL SELECT COUNT(1)
INTO :f_error
FROM ORDENENPROCESO
WHERE ID_PROCESO = :wid_proceso
AND NVL(IN_ERROR,0) = 1;

printf("\nf_error es actualizando %d", f_error);

if (f_error == 0)
{
EXEC SQL UPDATE ORDENENPROCESO
SET IN_ERROR = 1
WHERE NU_SECUENCIA = :wnu_secuencia
AND CD_COLA = :wCOLA;

F_Ins_ejecutadas();

printf("\nSECUENCIA %d ORDEN %d SUBORDEN %d termina mal, revisar ORDENEJECUTADA


(ST_B = 'S' y ST_C = 'M') F_Upd_CAOS\n",wnu_secuencia,wcd_orden,wcd_sub_orden);

if (f_orden == wcd_sub_orden)
{
EXEC SQL DELETE FROM ORDENENPROCESO
WHERE ID_PROCESO = :wid_proceso
AND CD_ORDEN = :wcd_orden
AND CD_COLA = :wCOLA
AND ST_B = 'S'
AND ST_C = 'M';
}
}

/********************************************************************/
/* Funcion comparar los campos de una orden de proceso */
/* Si hay una Orden anterior con ST_B = 'S' y ST_C = 'M' */
/* se marca wcaob_in_lenguaje = '*' para evitar que se procese la */
/* Orden que esta en ejecucion */
/********************************************************************/
F_Sel_compara()
{
EXEC SQL BEGIN DECLARE SECTION;
VARCHAR cadena[300];
int f_sub_orden;
EXEC SQL END DECLARE SECTION;

EXEC SQL DECLARE C_ORDEN_old CURSOR FOR


SELECT TO_char(FE_ORDEN,'DD-MM-YYYY')||' '||
TO_char(FE_ORDEN,'HH24:MI:SS')
FROM ORDENENPROCESO
WHERE NU_SECUENCIA < :wnu_secuencia
AND CD_ORDEN = :wcd_orden
AND CD_COLA = :wCOLA
AND ID_PROCESO = :wid_proceso
AND ST_B = 'S'
AND ST_C = 'M';

EXEC SQL OPEN C_ORDEN_old;


EXEC SQL FETCH C_ORDEN_old INTO :cadena;

if (sqlca.sqlcode == 0)
{
strcpy((char *) wcaob_in_lenguaje.arr,"*");
cadena.arr[cadena.len] = '\0';
}
EXEC SQL CLOSE C_ORDEN_old;
}

/********************************/
/* Marcar la orden en ejecucion */
/********************************/
F_Upd_EJECUCION()
{
EXEC SQL UPDATE ORDENENPROCESO
SET ST_B = '*'
WHERE NU_SECUENCIA = :wnu_secuencia;

if (sqlca.sqlcode != 0)
{
printf("\nError actualizando st_b el sqlcode es %s\n",sqlca.sqlerrm.sqlerrmc);
}
}
/*********************************************************************/
/* Funcion Para invocar procesos de lenguaje C */
/*********************************************************************/
F_Ins_lengc()
{
char filelog[30],outfile[30];
/**************************************************/
/* se inicializan los parametros */
/**************************************************/
wcaob_nm_programa.len = strlen((char *) wcaob_nm_programa.arr);
strcpy(parametro,(char *) wcaob_nm_programa.arr);
/**************************************************/
/* Convertir a char en numero de secuencia */
/**************************************************/
/*gconvert(wnu_secuencia,digitos,0,secuencia);*/
EXEC SQL SELECT LTRIM(TO_char(:wnu_secuencia))
INTO :secuencia
FROM DUAL;

secuencia.arr[secuencia.len] = '\0';
strcpy(filelog,(char *) wcaob_nm_programa.arr);
strcat(filelog,"_");
strcat(filelog,(char *) secuencia.arr);
strcat(filelog,".log");
strcpy(outfile,(char *) wcaob_nm_programa.arr);
strcat(outfile,"_");
strcat(outfile,(char *) secuencia.arr);
strcat(outfile,".lis");
strcpy((char *) waux_outfile.arr,outfile);

/* armar comando */
prg.len = sprintf(prg.arr,"%s%s %s %s %s > %s%s",wDIR_OBJ_PROC.arr,

wcaob_nm_programa.arr,secuencia.arr,wUsuario.arr,wClave.arr,wDIR_LOG_PROC.arr,filel
og);

/* Se invoca el comando */

printf("\nCOMANDO PRO C: %s\n",prg.arr);


fflush(stdout);
argc=system((char *) prg.arr);
F_Ins_monitorear();

/* Borrar archivo .log */


if (argc==0)
{
dellog.len = sprintf(dellog.arr,"rm %s%s \0",wDIR_LOG_PROC.arr,filelog);
system((char *) dellog.arr);
}
}

/************************************************************************/
/* Funcion para invocar los procesos de PL/SQL */
/************************************************************************/
F_Ins_plsql()
{
char filelog[30],outfile[30];

EXEC SQL SELECT LTRIM(TO_char(:wnu_secuencia))


INTO :secuencia
FROM DUAL;

secuencia.arr[secuencia.len] = '\0';
strcpy(filelog,(char *) wcaob_nm_programa.arr);
strcpy(outfile,(char *) wcaob_nm_programa.arr);
strcat(outfile,"_");
strcat(outfile,(char *) secuencia.arr);
strcat(outfile,".lis");
strcpy((char *) waux_outfile.arr,outfile);
strcat(filelog,"_");
strcat(filelog,(char *) secuencia.arr);
strcat(filelog,".log");

/* preparar comando */

prg.len = sprintf(prg.arr,"sqlplus -s %s%s%s @%s%s %s > %s


%s",wUsuario.arr,"/",wClave.arr,
wDIR_OBJ_PL.arr, wcaob_nm_programa.arr,secuencia.arr,wDIR_LOG_PL.arr,filelog);
printf("\nCOMANDO PLSQL: %s\n",prg.arr);
fflush(stdout);
argc=system((char *) prg.arr);
F_Ins_monitorear();

/* Borrar archivo .log */


if (argc==0)
{
dellog.len = sprintf(dellog.arr,"rm %s%s \0",wDIR_LOG_PL.arr,filelog);
system((char *) dellog.arr);
/* nuevo se agrega para NT */
dellog.len = sprintf(dellog.arr,"del %s%s \0",wDIR_LOG_PL.arr,filelog);
system((char *) dellog.arr);

}
}

/************************************************************************/
/* Funcion para invocar los procesos de Report en java */
/************************************************************************/
F_Ins_report()
{
char outfile[30],filelog[30];

/*gconvert(wnu_secuencia,digitos,0,secuencia);*/
EXEC SQL SELECT LTRIM(TO_char(:wnu_secuencia))
INTO :secuencia
FROM DUAL;

secuencia.arr[secuencia.len] = '\0';
strcpy(outfile,(char *) wcaob_nm_programa.arr);
strcat(outfile,"_");
strcat(outfile,(char *) secuencia.arr);
strcpy(filelog,outfile);
strcat(filelog,".log");

printf("\n entro en reporte tipo %s \n",win_modo.arr);


printf("\n entro en reporte delimitador %s \n",wcd_limitador.arr);
/* si es P la extension es pdf, si es X es excel si no txt */
EXEC SQL SELECT DECODE(:win_modo,'P','.pdf','X','.xls','.txt')
INTO :w_extension
FROM DUAL;

w_extension.arr[w_extension.len] = '\0';
strcat(outfile,(char *) w_extension.arr);
/*ant -Dargs="giosir giosir jdbc:oracle:thin:@gioserv5:1522:GIOSEGU
ReportePolizasPorSucursal 1 RepPolizas.pdf"*/
strcpy((char *) waux_outfile.arr,outfile);
prg.len = sprintf(prg.arr,"ant -Dargs=\"%s %s %s@%s:%s %s %s %s%s %s %s\" %s %s
%s",wUsuario.arr,wClave.arr,"jdbc:oracle:thin:",wREPSERVER.arr,
wALIAS.arr, wcaob_nm_programa.arr,secuencia.arr,
wDIR_LIS_REPO.arr, outfile,win_modo.arr,wcd_limitador.arr,">
",wDIR_LOG_REPO.arr,filelog);

strcpy(waux_outfile.arr,outfile);
printf("\nCOMANDO REPORT JAVA: %s\n",prg.arr);
fflush(stdout);
argc=system((char *) prg.arr);
F_Ins_monitorear();

/* si es impresion directa se envia a la impresora */


/* ejemplo de impresion lp -d EpsonLX300 salida/JRCJ00160_15282.txt */
if (wcaob_in_directa==1)
{

/* se busca la ubicacion de la impresora que es la que se envia en el comando unix


o windows*/
/* smb 20-03-2013 se cambia para que sea la impresora de la orden y no de
ordenejecucion */
EXEC SQL SELECT A.DE_UBICACION
INTO :w_de_ubicacion
FROM IMPRESORA A
WHERE A.CD_IMPRESORA = :wcd_impresora;
/*:wcaob_cd_impresora;*/

if (sqlca.sqlcode == 0)
{
w_de_ubicacion.arr[w_de_ubicacion.len] = '\0';

/* para unix */
dellog.len = sprintf(dellog.arr,"lp -d %s %s%s \
0",w_de_ubicacion.arr,wDIR_LIS_REPO.arr,outfile);
printf("\nCOMANDO IMPRESION DIRECTA: %s\n",dellog.arr);
system((char *) dellog.arr);

/* para windows print /d:\\gioserv2\HP1300N \\gioserv5\salida\JRCJ00160_9898.pdf


*/
dellog.len = sprintf(dellog.arr,"print /d:%s %s%s \
0",w_de_ubicacion.arr,wDIR_LIS_REPO.arr,outfile);
printf("\nCOMANDO IMPRESION WINDOW: %s\n",dellog.arr);
system((char *) dellog.arr);

}
}

/* Borrar archivo .log */


/* if (argc==0)
{
dellog.len = sprintf(dellog.arr,"rm %s%s \0",wDIR_LOG_REPO.arr,filelog);
system((char *) dellog.arr);
}*/
}

/************************************************************************/
/* Funcion para invocar los Correos Calendarios */
/************************************************************************/
F_Ins_calendario()
{
char outfile[30],filelog[30];
VARCHAR w_direccion[300];
VARCHAR w_mensaje[500];

EXEC SQL SELECT LTRIM(TO_char(:wnu_secuencia))


INTO :secuencia
FROM DUAL;

EXEC SQL SELECT TRIM(:wparam_6||:wparam_13)


INTO :w_direccion
FROM DUAL;

EXEC SQL SELECT TRIM(:wparam_5||:wparam_14||:wparam_15||:wparam_16||:wparam_17)


INTO :w_mensaje
FROM DUAL;

secuencia.arr[secuencia.len] = '\0';
w_direccion.arr[w_direccion.len] = '\0';
w_mensaje.arr[w_mensaje.len] = '\0';
strcpy(outfile,(char *) wcaob_nm_programa.arr);
strcat(outfile,"_");
strcat(outfile,(char *) secuencia.arr);
strcpy(filelog,outfile);
strcat(filelog,".log");

printf("\n entro en calendario %s \n",wparam_1.arr);

printf("\n direccion %s \n",w_direccion.arr);


printf("\n mensaje %s \n",w_mensaje.arr);

/* si se tardan mucho hay que agregar & para que se queden procesando */
/*ant calendario -Dargs="74.125.137.108 465 sir@gioseg.com complex12 'Agenda
Comercial' 'Texto del Mensaje' 'Direcci�n de la Reunion'
26062015 09:00 26062015 14:00 'Jose Romero:mailto:jose@gmail.com' 'Juan
Pablo,sandra_gioseg@yahoo.es;Keysis Kiss,keysiskiss@gmail.com'"*/
prg.len = sprintf(prg.arr,
"ant calendario -Dargs=\"%s %s %s %s \'%s\' \'%s\' \'%s\' %s %s %s
%s \'%s\' \'%s\' \" %s %s
%s",wparam_1.arr,wparam_12.arr,wparam_2.arr,wparam_3.arr,wparam_4.arr,w_mensaje.arr
,

w_direccion.arr,wparam_7.arr,wparam_8.arr,wparam_9.arr,wparam_10.arr,wparam_11.arr,
wdi_destinatario.arr,
" > ",wDIR_LOG_REPO.arr,filelog);
printf("\nCOMANDO CALENDARIO: %s\n",prg.arr);
fflush(stdout);
argc=system((char *) prg.arr);
F_Ins_monitorear();

/* Borrar archivo .log */


/* if (argc==0)
{
dellog.len = sprintf(dellog.arr,"rm %s%s \0",wDIR_LOG_REPO.arr,filelog);
system((char *) dellog.arr);
}*/
}

/************************************************************************/
/* Funcion para invocar los Web services */
/************************************************************************/
F_Ins_webservice()
{
char outfile[30],filelog[30];

EXEC SQL SELECT LTRIM(TO_char(:wnu_secuencia))


INTO :secuencia
FROM DUAL;

secuencia.arr[secuencia.len] = '\0';
strcpy(outfile,(char *) wcaob_nm_programa.arr);
strcat(outfile,"_");
strcat(outfile,(char *) secuencia.arr);
strcpy(filelog,outfile);
strcat(filelog,".log");

printf("\n entro en web service tipo %s \n",wparam_1.arr);

/* se agrega & para que los web services se queden procesando ya que se tardan
mucho en responder */
/* ant -file buildWS.xml -Dargs="giosir giosir
jdbc:oracle:thin:@gioserv7:1521:GIOSEGU 999 S" */
prg.len = sprintf(prg.arr,
"ant -file buildWS.xml -Dargs=\"%s %s %s@%s:%s %s %s\" %s %s%s
%s",wUsuario.arr,wClave.arr,"jdbc:oracle:thin:",wREPSERVER.arr,
wALIAS.arr,secuencia.arr,wparam_1.arr," > ",wDIR_LOG_REPO.arr,filelog," & ");

printf("\nCOMANDO WEB SERVICE: %s\n",prg.arr);


fflush(stdout);
argc=system((char *) prg.arr);
F_Ins_monitorear();

/* Borrar archivo .log */


/* if (argc==0)
{
dellog.len = sprintf(dellog.arr,"rm %s%s \0",wDIR_LOG_REPO.arr,filelog);
system((char *) dellog.arr);
}*/
}
/************************************************************************/
/* Funcion para invocar los procesos de Script */
/************************************************************************/
F_Ins_script()
{
char filelog[30],outfile[30];
/**************************************************/
/* se inicializan los parametros */
/**************************************************/
wcaob_nm_programa.len = strlen((char *) wcaob_nm_programa.arr);
strcpy(parametro,(char *) wcaob_nm_programa.arr);
/**************************************************/
/* Convertir a char en numero de secuencia */
/**************************************************/
/*gconvert(wnu_secuencia,digitos,0,secuencia);*/
EXEC SQL SELECT LTRIM(TO_char(:wnu_secuencia))
INTO :secuencia
FROM DUAL;

secuencia.arr[secuencia.len] = '\0';
strcpy(filelog,(char *) wcaob_nm_programa.arr);
strcat(filelog,"_");
strcat(filelog,(char *) secuencia.arr);
strcat(filelog,".log");
strcpy(outfile,(char *) wcaob_nm_programa.arr);
strcat(outfile,"_");
strcat(outfile,(char *)secuencia.arr);
strcat(outfile,".lis");
strcpy((char *) waux_outfile.arr,outfile);

/* armar comando */
prg.len = sprintf(prg.arr,"%s%s%s %s > %s%s",wDIR_OBJ_SCRIPT.arr,

wcaob_nm_programa.arr,".sh",wde_parametros_script.arr,wDIR_LOG_SCRIPT.arr,filelog);

/* Se invoca el comando */

printf("\nCOMANDO SCRIPT: %s",prg.arr);


fflush(stdout);
argc=system((char *) prg.arr);
F_Ins_monitorear();

/* Borrar archivo .log */


if (argc==0)
{
dellog.len = sprintf(dellog.arr,"rm %s%s \0",wDIR_LOG_SCRIPT.arr,filelog);
system((char *) dellog.arr);
}
}
/********************************************************/
/* Grabar en los archivos de log's */
/********************************************************/
F_Ins_monitorear()
{
EXEC SQL SELECT TO_char(SYSDATE,'DD-MM-YYYY HH24:MI:SS'),
TO_char(SYSDATE,'DD-MM-YYYY'),
TO_char(SYSDATE,'HH24:MI:SS')
INTO :wFECHA_HORA_FIN,
:wFECHA_FIN,
:wHORA_FIN
FROM DUAL;

wFECHA_HORA_FIN.arr[wFECHA_FIN.len] = '\0';
wFECHA_FIN.arr[wFECHA_FIN.len] = '\0';
wHORA_FIN.arr[wHORA_FIN.len] = '\0';

EXEC SQL SELECT (TO_NUMBER(TO_char(TO_DATE(:wFECHA_HORA_FIN,'DD-MM-YYYY


HH24:MI:SS'),'J')) -
TO_NUMBER(TO_char(TO_DATE(:wFECHA_HORA,'DD-MM-YYYY
HH24:MI:SS'),'J'))) * 1440
+ TO_NUMBER(TO_char(TO_DATE(:wFECHA_HORA_FIN,'DD-MM-YYYY
HH24:MI:SS'),'SSSSS')) / 60
- TO_NUMBER(TO_char(TO_DATE(:wFECHA_HORA,'DD-MM-YYYY
HH24:MI:SS'),'SSSSS')) / 60
INTO :wDif_MINUTOS
FROM DUAL;

EXEC SQL SELECT LTRIM(TO_char(TRUNC(:wDif_MINUTOS/60),'0999'))||':'||


LTRIM(TO_char(TRUNC(((:wDif_MINUTOS/60)-
TRUNC(:wDif_MINUTOS/60))*60),'09'))||':'||
LTRIM(TO_char(ROUND((((:wDif_MINUTOS/60)-
TRUNC(:wDif_MINUTOS/60))*60-TRUNC(((:wDif_MINUTOS/60)-
TRUNC(:wDif_MINUTOS/60))*60))*60),'09'))
INTO :wTIEMPO_DURACION
FROM DUAL;

wTIEMPO_DURACION.arr[wTIEMPO_DURACION.len] = '\0';

EXEC SQL SELECT (TO_NUMBER(TO_char(TO_DATE(:wFECHA_HORA_FIN,'DD-MM-YYYY


HH24:MI:SS'),'J')) -
TO_NUMBER(TO_char(TO_DATE(:wfe_hr_orden,'DD-MM-YYYY
HH24:MI:SS'),'J'))) * 1440
+ TO_NUMBER(TO_char(TO_DATE(:wFECHA_HORA_FIN,'DD-MM-YYYY
HH24:MI:SS'),'SSSSS')) / 60
- TO_NUMBER(TO_char(TO_DATE(:wfe_hr_orden,'DD-MM-YYYY
HH24:MI:SS'),'SSSSS')) / 60
INTO :wDif_MINUTOS_ORDEN
FROM DUAL;

EXEC SQL SELECT LTRIM(TO_char(TRUNC(:wDif_MINUTOS_ORDEN/60),'0999'))||':'||


LTRIM(TO_char(TRUNC(((:wDif_MINUTOS_ORDEN/60)-
TRUNC(:wDif_MINUTOS_ORDEN/60))*60),'09'))||':'||
LTRIM(TO_char(ROUND((((:wDif_MINUTOS_ORDEN/60)-
TRUNC(:wDif_MINUTOS_ORDEN/60))*60-TRUNC(((:wDif_MINUTOS_ORDEN/60)-
TRUNC(:wDif_MINUTOS_ORDEN/60))*60))*60),'09'))
INTO :wTIEMPO_DURACION_ORDEN
FROM DUAL;

wTIEMPO_DURACION_ORDEN.arr[wTIEMPO_DURACION_ORDEN.len] = '\0';

fprintf(joblog,"\nPROCESO EJECUTADO \n");


fprintf(joblog," Fecha y Hora Orden....> %s %s\n",wfe_orden.arr,whr_orden.arr);
fprintf(joblog," Fecha y Hora Inicio...> %s %s",wFECHA.arr,wHORA.arr);
fprintf(joblog," Programa...........> %s\n",wcaob_nm_programa.arr);
fprintf(joblog," Fecha y Hora Fin......> %s %s",wFECHA_FIN.arr,wHORA_FIN.arr);
fprintf(joblog," Nombre.............> %s\n",wcaob_nm_prelacion.arr);
fprintf(joblog," Nro. Secuencia........> %s",secuencia.arr);
fprintf(joblog," Prioridad..........>
%d\n",wcd_prioridad);
fprintf(joblog," Orden.................> %4d",wcd_orden);
fprintf(joblog," Lenguaje...........>
%s\n",wcaob_in_lenguaje.arr);
fprintf(joblog," Sub-Orden.............> %02d",wcd_sub_orden);
fprintf(joblog," Usuario............>
%s\n",wcd_usuario.arr);
fprintf(joblog,"CODIGO DE RETORNO......> %d\n",argc);

if (argc!=0)
{
fprintf(joblog,"\n ****************************************\n");
fprintf(joblog," ***********Proceso Abortado ************\n");
fprintf(joblog," ****************************************\n");
}
fprintf(job,"%s %s %s %s %s %s %s %s %s %s %s %10s %s %04d %02d %d %d %s%30-
s\n",wCOLA.arr,wfe_orden.arr,whr_orden.arr,wFECHA.arr,wHORA.arr,wFECHA_FIN.arr,wHOR
A_FIN.arr,wTIEMPO_DURACION_ORDEN.arr,wTIEMPO_DURACION.arr,wcaob_nm_programa.arr,wca
ob_in_lenguaje.arr,wcd_usuario.arr,secuencia.arr,wcd_orden,wcd_sub_orden,wcd_priori
dad,argc," ",wcaob_nm_prelacion.arr);
fflush(job);
fflush(joblog);
}

/********************************************************/
/* Funcion para actualizar IMPRESION */
/********************************************************/
F_Upd_impresiones()
{
char archivo_salida[60];
struct stat buff;

printf("\n Prueba antes de copiar dir y nombre %s %s \n",wDIR_LIS.arr,


rnm_programa.arr);

strcpy((char *) rnm_programa.arr,(char *) waux_outfile.arr);


strcpy(archivo_salida,(char *) wDIR_LIS.arr);
strcat(archivo_salida,(char *) rnm_programa.arr);

printf("\n Prueba imp.sh xxx: %s %s \n",wDIR_LIS.arr, rnm_programa.arr);

if (archivo=fopen(archivo_salida,"rb"))
{
fstat(fileno(archivo),&buff);
rcaos_longitud = buff.st_size;
fclose(archivo);
rnm_programa.len = strlen(rnm_programa.arr);
rnm_programa.arr[rnm_programa.len] = '\0';
rcd_prioridad = 3;

strcpy((char *) rst_programa.arr,"E");

rst_programa.len = strlen(rst_programa.arr);
rst_programa.arr[rst_programa.len] = '\0';
EXEC SQL SELECT B.NM_SCRIPT_SALIDA
INTO :wcaob_nm_form
FROM IMPRESORA A,
IMPRESORABASE B
WHERE A.CD_IMPRESORA = :wcd_impresora
AND B.CD_IMPRESORA = A.CD_IMPRESORA
AND B.NU_LONGITUD_SALIDA = :wcaob_nu_longitud;

if (sqlca.sqlcode == 0)
wcaob_nm_form.arr[wcaob_nm_form.len] = '\0';

/*
printf("\n wnu_secuencia %d ",wnu_secuencia);
printf("\n rnm_programa %s ",rnm_programa.arr);
printf("\n wcd_usuario %s ",wcd_usuario.arr);
printf("\n wnu_copias %d ",wnu_copias);
printf("\n rcd_prioridad %d ",rcd_prioridad);
printf("\n rst_programa %s ",rst_programa.arr);
printf("\n wcd_impresora %s ",wcd_impresora.arr);
printf("\n wfe_orden %s ",wfe_orden.arr);
printf("\n wFECHA_HORA %s ",wFECHA_HORA.arr);
*/
EXEC SQL INSERT INTO IMPRESION(
VERSION ,
NU_SECUENCIA ,
CD_ORDEN ,
CD_SUBORDEN ,
NM_ARCHIVO ,
NU_COPIAS ,
CD_USUARIO ,
CD_PRIORIDAD ,
ST_ARCHIVO ,
CD_IMPRESORA ,
FE_PROCESO ,
FE_IMPRESION ,
TP_IMPRESION ,
NU_LONGITUD_SALIDA ,
NU_BYTES ,
NM_MAQUINA,
NM_SCRIPT_SALIDA,
IN_MODO,
CD_CARACTER_DELIMITADOR)
VALUES (0,
:wnu_secuencia,
:wcd_orden,
:wcd_sub_orden,
:rnm_programa,
:wnu_copias,
:wcd_usuario,
:rcd_prioridad,
:rst_programa,
:wcd_impresora,
TO_DATE(:wfe_orden,'DD-MM-YYYY'),
/* se usa fecha de impresion para grabar la orden con hora y es la que se mostrara
en la pagina de reportes */
TO_date(:wfe_hr_orden,'DD-MM-YYYY HH24:MI:SS'),
:wcaob_tp_impresion,
:wcaob_nu_longitud,
:rcaos_longitud,
:wMAQUINA,
:wcaob_nm_form,
:win_modo,
:wcd_limitador);

if (sqlca.sqlcode == 0)
{
fprintf(joblog," Se genera Reporte.....> %s",rnm_programa.arr);
fprintf(joblog," Longitud...........> %d\n",rcaos_longitud);
fprintf(joblog," Impresora.............> %6s",wcd_impresora.arr);
fprintf(joblog," Copias.............>
%d\n",wnu_copias);
}
else
{
printf("\nError insertando en IMPRESION en F_Upd_impresiones ");
printf("\nel sqlcode es %s \n",sqlca.sqlerrm.sqlerrmc);
fprintf(joblog,"\n Error insertando en IMPRESION (sqlcode
%s)\n",sqlca.sqlerrm.sqlerrmc);
}
}
else
printf("\n Error: No puede abrir el archivo %s en
F_Upd_impresiones\n",archivo_salida);

fflush(stdout);
}
/********************************************************
Impresion inmediata del reporte
********************************************************/
F_Ins_imprimir()
{
int i;
char cmd_unix[200];

EXEC SQL SELECT SUBSTR(:wcaob_nm_programa,4,1)


INTO :wTIPO_LIS
FROM DUAL;

wTIPO_LIS.arr[wTIPO_LIS.len] = '\0';

if (strcmp((char * )wTIPO_LIS.arr,(char * )"P") == 0)


strcpy((char * )wDIR_LIS.arr,(char * )wDIR_LIS_PL.arr);
else
if (strcmp((char * )wTIPO_LIS.arr,(char * )"C") == 0)
strcpy((char * )wDIR_LIS.arr,(char * )wDIR_LIS_PROC.arr);
else
if (strcmp((char * )wTIPO_LIS.arr,(char * )"R") == 0)
strcpy((char * )wDIR_LIS.arr,(char * )wDIR_LIS_REPO.arr);
else
strcpy((char * )wDIR_LIS.arr,(char * )wDIR_LIS_SCRIPT.arr);

wDIR_LIS.len = strlen(wDIR_LIS.arr);
wDIR_LIS.arr[wDIR_LIS.len] = '\0';

/* cesar */
/* strcpy((char * )cmd_unix,(char * )wDIR_OBJ_SCRIPT.arr);
strcat((char * )cmd_unix,(char * )"LP.sh ");
strcat((char * )cmd_unix,(char * )wMAQUINA.arr);
strcat((char * )cmd_unix,(char * )" ");
strcat((char * )cmd_unix,(char * )wcaob_nm_form.arr);
strcat((char * )cmd_unix,(char * )" ");
strcat((char * )cmd_unix,(char * )wDIR_LIS.arr);
strcat((char * )cmd_unix,(char * )" ");
strcat((char * )cmd_unix,(char * )rnm_programa.arr);
strcat((char * )cmd_unix,(char * )" ");
strcat((char * )cmd_unix,(char * )wcd_impresora.arr);
strcat((char * )cmd_unix,(char * )" ");
strcat((char * )cmd_unix,(char * )wnu_copias_w.arr);
strcat((char * )cmd_unix,(char * )" > /dev/null"); /*

if (strcmp((char * )wTIPO_LIS.arr,(char * )"R") == 0)


strcpy((char * )cmd_unix,(char * )"/oracle9ias/ias/bin/imppdf2.sh ");
else
strcpy((char * )cmd_unix,(char * )"/oracle9ias/ias/bin/imp2.sh ");

strcat((char * )cmd_unix,(char * )wcd_impresora.arr);


strcat((char * )cmd_unix,(char * )" ");
strcat((char * )cmd_unix,(char * )rnm_programa.arr);
strcat((char * )cmd_unix,(char * )" ");
strcat((char * )cmd_unix,(char * )wDIR_BASES.arr);
strcat((char * )cmd_unix,(char * )wcaob_nm_form.arr);
strcat((char * )cmd_unix,(char * )" ");
strcat((char * )cmd_unix,(char * )wDIR_LIS.arr);

/****************************************
Ejecutar el comando de impresion
***************************************/

printf("\nComando de Impresion %s \n",cmd_unix);


argc=system(cmd_unix);
printf("Se ejecuto comando de impresion. Codigo de retorno %d \n",argc);
}
/****************************************
Crear archivos de log
***************************************/
F_Crear_archivo()
{
char archivo_salida[120]; /* Archivo para operador */
char archivo_salida1[120]; /* Archivo general */
/* SE COMENTA PARA ELMINAR EL ARCHIVO EN JOBLIST Y REEMPLAZARLO POR EL JOBLOG
EXEC SQL SELECT :wDIR_LOG_SCRIPT||'JOBLIST_'||:wCOLA||
to_char(sysdate,'YYYYMMDD')||'.lis'
INTO :Joblist
FROM dual;
*/
EXEC SQL SELECT :wDIR_LOG_SCRIPT||'JOBLOG_'||
TO_char(SYSDATE,'YYYYMMDD')||'.log'
INTO :Joblist
FROM dual;

EXEC SQL SELECT TO_NUMBER(TO_char(SYSDATE,'HH24'))


INTO :wHORAJOB
FROM dual;

Joblist.arr[Joblist.len] = '\0';
strcpy(archivo_salida,(char *) Joblist.arr);

printf("\n direc joblist %s ", Joblist.arr);


printf("\n archivo salida ");

if (job=fopen(archivo_salida,"r"))
job=fopen(archivo_salida,"a");
else
{
job=fopen(archivo_salida,"w");
fprintf(job,"C FECHA ORD HORA ORD FECHA INI HORA INI FECHA FIN HORA FIN
DURAC ORD DURAC EJE PROGRAMA L USUARIO SECUEN ORDE SO P CR NOMBRE
PROGRAMA\n");
}

printf("\n antes de aramar cola");

EXEC SQL SELECT :wDIR_LOG_SCRIPT||'COLA_'||:wCOLA||'_'||


TO_char(SYSDATE,'YYYYMMDD')||'.log'
INTO :Joblist
FROM dual;

printf("\n direc cola joblist %s ", Joblist.arr);

if (sqlca.sqlcode != 0)
{
printf("\nError en preparacion de archivo log general en F_Crear_archivo");
printf("\nel sqlcode es %s",sqlca.sqlerrm.sqlerrmc);
exit(1);
}

Joblist.arr[Joblist.len] = '\0';
strcpy(archivo_salida1,(char *) Joblist.arr);

printf("\n antes de abir archivo de cola");


if (joblog=fopen(archivo_salida1,"r"))
joblog=fopen(archivo_salida1,"a");
else
joblog=fopen(archivo_salida1,"w");
printf("\n desp de abir archivo de cola");
}
/*********************************************/
/* Se determina el status de la cola */
/*********************************************/
int F_Revisa_Cola()
{
EXEC SQL SELECT ST_COLA
INTO :paso
FROM COLA
WHERE CD_COLA = :wCOLA;

if (sqlca.sqlcode != 0)
{
printf("\nError verificando Cola en F_Rea_Cola el sqlcode es
%s\n",sqlca.sqlerrm.sqlerrmc);
exit(1);
}

/* smb 27-05-2013 si la cola esta parada mejor no revisar los programas, porque
mientras se hace commit */
/* lo puede agarrar otro proceso */
/*if (paso == 1)
F_Revisa_Programa();
else*/
if (paso == 9)
printf("\n LA COLA %s ESTA DETENIDA....\n",wCOLA.arr);

return(paso);
}
/***************************************************/
/* Revisar cual programa se esta ejecutando */
/***************************************************/

F_Revisa_Programa()
{
EXEC SQL SELECT A.NU_SECUENCIA,
A.CD_ORDEN,
A.CD_SUBORDEN,
B.NM_PROGRAMA
INTO :wnu_secuencia_rev,
:wcd_orden_rev,
:wcd_sub_orden_rev,
:wnm_programa_rev
FROM ORDENENPROCESO A,
ORDENEJECUCION B
WHERE A.CD_COLA = :wCOLA
AND A.ST_B = '*'
AND A.CD_ORDEN = B.CD_ORDEN
AND A.CD_SUBORDEN = B.CD_SUBORDEN;

if (sqlca.sqlcode != 0) /* No hay programa en ejecucion */


{
paso = 0; /* Se desbloquea la cola */
}
else
{
wnm_programa_rev.arr[wnm_programa_rev.len] = '\0';
printf("\nLA COLA ESTA OCUPADA..... ");
printf("Secuencia: %d Orden: %d Sub_Orden: %d Programa:
%s\n",wnu_secuencia_rev,wcd_orden_rev,wcd_sub_orden_rev,wnm_programa_rev.arr);
}
}

int F_Chequea_Cola()
{

wparada=0;
EXEC SQL SELECT ST_COLA
INTO :wparada
FROM COLA
WHERE CD_COLA = :wCOLA;
if (sqlca.sqlcode != 0)
{
printf("\nError en F_Chequea_Cola el sqlcode es %s\n",sqlca.sqlerrm.sqlerrmc);
EXEC SQL ROLLBACK WORK RELEASE;
exit(1);
}
else
{
if (wparada == 9)
printf("\n SE DETIENE LA COLA %s STATUS %d ....\n",wCOLA.arr,wparada);
}
fflush(stdout);
return(wparada);
}
/******************************************************
Esta Funcion inserta en ORDENPROCESANDO el programa
que van a ser bloqueado para ejecutarse
******************************************************/
F_Ins_EJECUCION()
{
EXEC SQL INSERT INTO ORDENPROCESANDO
(VERSION,
NU_SECUENCIA,
CD_ORDEN,
CD_SUBORDEN,
FE_ORDEN,
CD_USUARIO,
HR_ENTRADA)
SELECT 0,
NU_SECUENCIA,
CD_ORDEN,
CD_SUBORDEN,
FE_ORDEN,
CD_USUARIO,
SYSDATE
FROM ORDENENPROCESO
WHERE NU_SECUENCIA = :wnu_secuencia;

if (sqlca.sqlcode != 0)
{
printf("\nError insertando ORDENPROCESANDO en F_Ins_EJECUCION");
printf("\nel sqlcode es %s",sqlca.sqlerrm.sqlerrmc);
EXEC SQL ROLLBACK WORK RELEASE;
exit(1);
}
}

/* Borrar registros procesados */


F_Del_EJECUCION()
{
EXEC SQL DELETE FROM ORDENPROCESANDO
WHERE NU_SECUENCIA = :wnu_secuencia;

if (sqlca.sqlcode != 0)
{
printf("\nError borrando ORDENPROCESANDO en F_Del_Jobs el sqlcode es
%s\n",sqlca.sqlerrm.sqlerrmc);
}
}

/* Funcion para buscar el ambiente de la maquina */


F_Sel_Ambiente()
{
EXEC SQL SELECT DI_OBJETOS_PL,
DI_OBJETOS_PROC,
DI_OBJETOS_REP,
DI_SALIDAS_PL,
DI_SALIDAS_PROC,
DI_SALIDAS_REP,
DI_LOG_PL,
DI_LOG_PROC,
DI_LOG_REP,
'NINGUNO', -- OJO NVL(DI_OBJETOS_SH,'NINGUNO'),
'NINGUNO', -- OJO NVL(DI_SALIDAS_SH,'NINGUNO'),
NVL(DI_SALIDA_OTROS,'NINGUNO'), --SE UTUILIZA PARA EL JOBLOG
NVL(NM_REPSERV,'NINGUNO'),
'NINGUNO' --OJO DI_BASES_IMPRESORAS
INTO :wDIR_OBJ_PL,
:wDIR_OBJ_PROC,
:wDIR_OBJ_REPO,
:wDIR_LIS_PL,
:wDIR_LIS_PROC,
:wDIR_LIS_REPO,
:wDIR_LOG_PL,
:wDIR_LOG_PROC,
:wDIR_LOG_REPO,
:wDIR_OBJ_SCRIPT,
:wDIR_LIS_SCRIPT,
:wDIR_LOG_SCRIPT,
:wREPSERVER,
:wDIR_BASES
FROM AMBIENTE
WHERE NM_MAQUINA = :wMAQUINA;

if (sqlca.sqlcode != 0)
{
printf("\nError en busqueda del ambiente en F_Sel_Ambiente el sqlcode es
%s\n",sqlca.sqlerrm.sqlerrmc);
exit(1);
}
wDIR_OBJ_PL.arr[wDIR_OBJ_PL.len] = '\0';
wDIR_OBJ_PROC.arr[wDIR_OBJ_PROC.len] = '\0';
wDIR_OBJ_REPO.arr[wDIR_OBJ_REPO.len] = '\0';
wDIR_LIS_REPO.arr[wDIR_LIS_REPO.len] = '\0';
wDIR_LIS_PROC.arr[wDIR_LIS_PROC.len] = '\0';
wDIR_LIS_PL.arr[wDIR_LIS_PL.len] = '\0';
wDIR_LOG_REPO.arr[wDIR_LOG_REPO.len] = '\0';
wDIR_LOG_PROC.arr[wDIR_LOG_PROC.len] = '\0';
wDIR_LOG_PL.arr[wDIR_LOG_PL.len] = '\0';
wDIR_OBJ_SCRIPT.arr[wDIR_OBJ_SCRIPT.len] = '\0';
wDIR_LIS_SCRIPT.arr[wDIR_LIS_SCRIPT.len] = '\0';
wDIR_LOG_SCRIPT.arr[wDIR_LOG_SCRIPT.len] = '\0';
wDIR_BASES.arr[wDIR_BASES.len] = '\0';
}

/* Funcion para determinar si hay una orden en ejecucion */


/* que es critica con la orden a ejecutar */
int F_Sel_Critica()
{
EXEC SQL SELECT 1
INTO :paso
FROM ORDENPROCESANDO A
,ORDENCRITICA B
WHERE A.CD_ORDEN = B.CD_ORDEN
AND B.CD_ORDEN_CRITICA = :wcd_orden
AND A.NU_SECUENCIA != :wnu_secuencia;

if (sqlca.sqlcode == 0)
return(1);
else
return(0);
}