brajan_aldana/RPAClaroLogin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Ajustes jef

Browse Source
This commit is contained in:
brajan_aldana
2025-06-11 15:00:59 -05:00
parent 12bd499a2f
commit acf02d5bdb
6 changed files with 4872 additions and 1024 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rr.js
+583 -52
View File
@@ -1,39 +1,180 @@
const fs = require('fs');
const path = require('path');
const { dialog } = require('electron');
const os = require('os');
// Función para verificar y encontrar la DLL de AutoIt
function findAutoItDLL() {
const { app } = require('electron');
const isPackaged = app ? app.isPackaged : false;
// Especifica el nombre del archivo que deseas generar
const nombreArchivo = path.join('C:', 'RpaClaro', 'macrologin.mac');
console.log(`[DLL] Aplicación empaquetada: ${isPackaged}`);
let possiblePaths;
// Función para verificar y eliminar el archivo
function verificarYEliminarArchivo(nombreArchivo) {
if (fs.existsSync(nombreArchivo)) {
try {
// fs.unlinkSync(nombreArchivo); // Descomentar para eliminar el archivo
console.log(`Se ha eliminado el archivo '${nombreArchivo}'.`);
} catch (e) {
console.log(`Error al eliminar el archivo '${nombreArchivo}': ${e}`);
}
if (isPackaged) {
possiblePaths = [
// 1. PRIMERA PRIORIDAD: Ruta fija del sistema
'C:/RpaClaro/AutoItX3_x64.dll',
// 2. extraResources (copiados por electron-builder)
path.join(process.resourcesPath, 'dlls', 'AutoItX3_x64.dll'),
// 3. app.asar.unpacked (desempaquetados)
path.join(process.resourcesPath, 'app.asar.unpacked', 'dlls', 'AutoItX3_x64.dll'),
path.join(process.resourcesPath, 'app.asar.unpacked', 'node_modules', 'node-autoit-koffi', 'lib', 'AutoItX3_x64.dll'),
// 4. extraFiles (directorio de instalación)
path.join(path.dirname(process.execPath), 'dlls', 'AutoItX3_x64.dll'),
path.join(path.dirname(process.execPath), 'lib', 'autoit', 'AutoItX3_x64.dll'),
// 5. Fallbacks
'C:/RpaClaro/AutoItX3.dll',
path.join(process.resourcesPath, 'dlls', 'AutoItX3.dll')
];
} else {
console.log(`El archivo '${nombreArchivo}' no existe.`);
possiblePaths = [
// Desarrollo
'C:/RpaClaro/AutoItX3_x64.dll',
path.join(__dirname, 'dlls', 'AutoItX3_x64.dll'),
path.join(process.cwd(), 'dlls', 'AutoItX3_x64.dll'),
'C:/Users/TARS/Desktop/rpa/dlls/AutoItX3_x64.dll'
];
}
console.log('[DLL] Buscando AutoIt DLL en rutas posibles...');
for (const dllPath of possiblePaths) {
console.log(`[DLL] Verificando: ${dllPath}`);
try {
if (fs.existsSync(dllPath)) {
console.log(`[DLL] ✓ DLL encontrada en: ${dllPath}`);
const stats = fs.statSync(dllPath);
console.log(`[DLL] ✓ Tamaño del archivo: ${stats.size} bytes`);
if (stats.size > 100000) {
console.log(`[DLL] ✓ DLL válida encontrada: ${dllPath}`);
return dllPath;
}
}
} catch (error) {
console.log(`[DLL] ✗ Error verificando ${dllPath}: ${error.message}`);
}
}
console.log('[DLL] ✗ No se encontró AutoIt DLL válida en ninguna ruta');
return null;
}
// Función mejorada para copiar DLLs
function ensureDLLsAvailable() {
const { app } = require('electron');
const isPackaged = app ? app.isPackaged : false;
if (!isPackaged) {
console.log('[DLL_COPY] Modo desarrollo, no se requiere copia de DLLs');
return;
}
console.log('[DLL_COPY] Verificando disponibilidad de DLLs para aplicación empaquetada...');
// Verificar primero en extraResources
const resourcesPath = process.resourcesPath;
const resourcesDllPath = path.join(resourcesPath, 'dlls', 'AutoItX3_x64.dll');
if (fs.existsSync(resourcesDllPath)) {
console.log(`[DLL_COPY] ✓ DLL encontrada en extraResources: ${resourcesDllPath}`);
return; // No necesitamos copiar, ya está disponible
}
// Si no está en extraResources, intentar copiar desde sistema
const sourcePaths = [
'C:/RpaClaro/AutoItX3_x64.dll',
'C:/RpaClaro/AutoItX3.dll'
];
const targetDir = path.join(path.dirname(process.execPath), 'dlls');
// Crear directorio dlls si no existe
if (!fs.existsSync(targetDir)) {
try {
fs.mkdirSync(targetDir, { recursive: true });
console.log(`[DLL_COPY] ✓ Directorio creado: ${targetDir}`);
} catch (error) {
console.log(`[DLL_COPY] ✗ Error creando directorio: ${error.message}`);
return;
}
}
for (const sourcePath of sourcePaths) {
if (fs.existsSync(sourcePath)) {
const fileName = path.basename(sourcePath);
const targetPath = path.join(targetDir, fileName);
if (!fs.existsSync(targetPath)) {
try {
fs.copyFileSync(sourcePath, targetPath);
console.log(`[DLL_COPY] ✓ DLL copiada: ${sourcePath} → ${targetPath}`);
} catch (error) {
console.log(`[DLL_COPY] ✗ Error copiando DLL: ${error.message}`);
}
} else {
console.log(`[DLL_COPY] ℹ DLL ya existe: ${targetPath}`);
}
}
}
}
// Función para generar el archivo
function generarArchivo(nombreArchivo, contenido) {
try {
// Crea el archivo y escribe el contenido
fs.writeFileSync(nombreArchivo, contenido, 'utf8');
console.log(`Se ha generado el archivo '${nombreArchivo}' con éxito.`);
} catch (e) {
console.log(`Error al generar el archivo '${nombreArchivo}': ${e}`);
}
function debugPaths() {
const { app } = require('electron');
console.log('\n=== DEBUGGING PATHS ===');
console.log(`process.execPath: ${process.execPath}`);
console.log(`process.resourcesPath: ${process.resourcesPath}`);
console.log(`app.getAppPath(): ${app ? app.getAppPath() : 'N/A'}`);
console.log(`__dirname: ${__dirname}`);
console.log(`process.cwd(): ${process.cwd()}`);
console.log(`app.isPackaged: ${app ? app.isPackaged : 'N/A'}`);
// Verificar si existen las rutas críticas
const criticalPaths = [
path.join(process.resourcesPath, 'dlls'),
path.join(path.dirname(process.execPath), 'dlls'),
'C:/RpaClaro'
];
criticalPaths.forEach(criticalPath => {
console.log(`${criticalPath}: ${fs.existsSync(criticalPath) ? '✓ EXISTS' : '✗ NOT FOUND'}`);
if (fs.existsSync(criticalPath)) {
try {
const files = fs.readdirSync(criticalPath);
console.log(` Files: ${files.join(', ')}`);
} catch (e) {
console.log(` Error reading directory: ${e.message}`);
}
}
});
console.log('========================\n');
}
// Función principal actualizada
function rr(usuario, password) {
console.log('\n=== INICIANDO FUNCIÓN RR() ===');
// Ahora, formateamos el texto para insertar el valor de "valor_variable" en el lugar correcto.
debugPaths();
console.log(`[AUTH] Usuario: ${usuario}`);
console.log(`[AUTH] Password: ${'*'.repeat(password.length)} (longitud: ${password.length})`);
// Verificar arquitectura del sistema
const systemArch = checkSystemArchitecture();
// PASO CRÍTICO: Asegurar que las DLLs estén disponibles
ensureDLLsAvailable();
// Generar contenido del archivo de macro (código existente...)
const texto = `<HAScript name="macrologin" description="" timeout="60000" pausetime="300" promptall="true" blockinput="true" author="Usuario" creationdate="19/07/2023 07:57:48 PM" supressclearevents="false" usevars="true" ignorepauseforenhancedtn="true" delayifnotenhancedtn="0" ignorepausetimeforenhancedtn="true" continueontimeout="false">
<screen name="Pantalla1" entryscreen="true" exitscreen="true" transient="false">
<description >
@@ -60,106 +201,496 @@ function rr(usuario, password) {
</screen>
</HAScript>`;
// Llamada para verificar y eliminar el archivo si existe
console.log(`[MACRO] Contenido de macro generado con ${texto.split('\n').length} líneas`);
// Verificar y eliminar archivo existente
const nombreArchivo = path.join('C:', 'RpaClaro', 'macrologin.mac');
verificarYEliminarArchivo(nombreArchivo);
// Llamada para generar el nuevo archivo
// Generar nuevo archivo
generarArchivo(nombreArchivo, texto);
async function runAS400Launcher() {
const autoit = require("node-autoit-koffi");
const koffi = require("koffi");
autoit.lib = koffi.load('C:/RpaClaro/AutoItX3_x64.dll');
await autoit.run('C:/Users/Public/IBM/ClientSolutions/Start_Programs/Windows_i386-32/acslaunch_win-32.exe C:/RpaClaro/AS400.hod');
async function loadAutoItWithDependencies(autoItDllPath) {
const { app } = require('electron');
const path = require('path');
const fs = require('fs');
console.log('[AUTOIT_LOADER] Iniciando carga de AutoIt con dependencias...');
try {
// 1. Configurar rutas de módulos nativos
if (app.isPackaged) {
const unpackedPath = path.join(process.resourcesPath, 'app.asar.unpacked', 'node_modules');
const nodeModulesPath = path.join(process.resourcesPath, 'node_modules');
// Agregar rutas a la resolución de módulos
if (fs.existsSync(unpackedPath)) {
require('module').globalPaths.unshift(unpackedPath);
console.log(`[AUTOIT_LOADER] ✓ Ruta desempaquetada agregada: ${unpackedPath}`);
}
if (fs.existsSync(nodeModulesPath)) {
require('module').globalPaths.unshift(nodeModulesPath);
console.log(`[AUTOIT_LOADER] ✓ Ruta node_modules agregada: ${nodeModulesPath}`);
}
// Configurar PATH para DLLs nativas
const dllDir = path.dirname(autoItDllPath);
const currentPath = process.env.PATH || '';
if (!currentPath.includes(dllDir)) {
process.env.PATH = `${dllDir};${currentPath}`;
console.log(`[AUTOIT_LOADER] ✓ PATH actualizado con: ${dllDir}`);
}
}
// 2. Cargar node-gyp-build manualmente si está disponible
try {
const nodeGypBuild = require('node-gyp-build');
console.log('[AUTOIT_LOADER] ✓ node-gyp-build cargado exitosamente');
} catch (nodeGypError) {
console.log(`[AUTOIT_LOADER] ⚠ node-gyp-build no disponible: ${nodeGypError.message}`);
// Intentar cargar desde ruta desempaquetada
if (app.isPackaged) {
const nodeGypPath = path.join(process.resourcesPath, 'app.asar.unpacked', 'node_modules', 'node-gyp-build');
if (fs.existsSync(nodeGypPath)) {
try {
require(nodeGypPath);
console.log('[AUTOIT_LOADER] ✓ node-gyp-build cargado desde ruta desempaquetada');
} catch (e) {
console.log(`[AUTOIT_LOADER] ✗ Error cargando node-gyp-build: ${e.message}`);
}
}
}
}
// 3. Cargar koffi
console.log('[AUTOIT_LOADER] Cargando koffi...');
const koffi = require('koffi');
console.log('[AUTOIT_LOADER] ✓ Koffi cargado exitosamente');
// 4. Cargar node-autoit-koffi
console.log('[AUTOIT_LOADER] Cargando node-autoit-koffi...');
let autoit;
if (app.isPackaged) {
// Intentar desde ruta desempaquetada primero
const autoitModulePath = path.join(process.resourcesPath, 'app.asar.unpacked', 'node_modules', 'node-autoit-koffi');
if (fs.existsSync(autoitModulePath)) {
autoit = require(autoitModulePath);
console.log('[AUTOIT_LOADER] ✓ node-autoit-koffi cargado desde ruta desempaquetada');
} else {
autoit = require('node-autoit-koffi');
console.log('[AUTOIT_LOADER] ✓ node-autoit-koffi cargado normalmente');
}
} else {
autoit = require('node-autoit-koffi');
console.log('[AUTOIT_LOADER] ✓ node-autoit-koffi cargado (modo desarrollo)');
}
// 5. Configurar DLL si el módulo lo soporta
if (autoit.setDllPath && typeof autoit.setDllPath === 'function') {
autoit.setDllPath(autoItDllPath);
console.log('[AUTOIT_LOADER] ✓ Ruta DLL configurada manualmente');
}
console.log('[AUTOIT_LOADER] ✓ AutoIt cargado exitosamente');
return autoit;
} catch (error) {
console.error(`[AUTOIT_LOADER] ✗ Error crítico cargando AutoIt: ${error.message}`);
console.error(`[AUTOIT_LOADER] Stack trace: ${error.stack}`);
// Diagnóstico específico para node-gyp-build
if (error.message.includes('Cannot find module \'node-gyp-build\'')) {
console.log('[AUTOIT_LOADER] ℹ Error específico: node-gyp-build faltante');
const suggestions = [
'1. Ejecutar: npm install node-gyp-build --save',
'2. Agregar node-gyp-build a asarUnpack en package.json',
'3. Ejecutar: npm run rebuild',
'4. Verificar que todas las dependencias nativas estén instaladas'
];
console.log('[AUTOIT_LOADER] Sugerencias para solucionar:');
suggestions.forEach(suggestion => console.log(`[AUTOIT_LOADER] ${suggestion}`));
}
throw error;
}
}
async function runAS400Launcher() {
console.log('\n=== INICIANDO AS400 LAUNCHER ===');
try {
// Buscar la DLL de AutoIt
const autoItDllPath = findAutoItDLL();
if (!autoItDllPath) {
console.log('[DLL] ✗ ERROR CRÍTICO: No se pudo encontrar AutoItX3.dll');
return;
}
// Usar el nuevo cargador
const autoit = await loadAutoItWithDependencies(autoItDllPath);
// Continuar con el resto del código AS400...
console.log('[SETUP] ✓ AutoIt configurado, continuando con AS400...');
// Reemplaza la sección de carga de Koffi en runAS400Launcher()
try {
console.log(`[DLL] Cargando AutoIt DLL desde: ${autoItDllPath}`);
// Cargar koffi y autoit con manejo de errores mejorado
//let autoit, koffi;
try {
console.log(`[DLL] Cargando AutoIt DLL desde: ${autoItDllPath}`);
// Verificar acceso a la DLL
console.log('[DLL] Verificando acceso a la DLL...');
fs.accessSync(autoItDllPath, fs.constants.R_OK);
console.log('[DLL] ✓ DLL accesible para lectura');
// Configurar variables de entorno para librerías nativas
const { app } = require('electron');
if (app.isPackaged) {
// Agregar rutas de DLLs al PATH del proceso
const dllDir = path.dirname(autoItDllPath);
const currentPath = process.env.PATH || '';
if (!currentPath.includes(dllDir)) {
process.env.PATH = `${dllDir};${currentPath}`;
console.log(`[ENV] ✓ Agregada ruta DLL al PATH: ${dllDir}`);
}
// Configurar ruta de librerías desempaquetadas
const unpackedPath = path.join(process.resourcesPath, 'app.asar.unpacked', 'node_modules');
if (fs.existsSync(unpackedPath)) {
require('module').globalPaths.push(unpackedPath);
console.log(`[ENV] ✓ Agregada ruta de módulos desempaquetados: ${unpackedPath}`);
}
}
// Cargar koffi primero
console.log('[KOFFI] Cargando koffi...');
const koffi = require("koffi");
console.log('[KOFFI] ✓ Koffi cargado exitosamente');
// Cargar node-autoit-koffi
console.log('[AUTOIT] Cargando node-autoit-koffi...');
let autoit;
if (app.isPackaged) {
// En aplicación empaquetada, cargar desde ruta desempaquetada
const autoitModulePath = path.join(process.resourcesPath, 'app.asar.unpacked', 'node_modules', 'node-autoit-koffi');
if (fs.existsSync(autoitModulePath)) {
autoit = require(autoitModulePath);
console.log('[AUTOIT] ✓ node-autoit-koffi cargado desde ruta desempaquetada');
} else {
autoit = require("node-autoit-koffi");
console.log('[AUTOIT] ✓ node-autoit-koffi cargado normalmente');
}
} else {
autoit = require("node-autoit-koffi");
console.log('[AUTOIT] ✓ node-autoit-koffi cargado (modo desarrollo)');
}
// Configurar la DLL manualmente si es necesario
if (autoit.setDllPath && typeof autoit.setDllPath === 'function') {
autoit.setDllPath(autoItDllPath);
console.log('[AUTOIT] ✓ Ruta DLL configurada manualmente');
}
console.log('[SETUP] ✓ Configuración de AutoIt completada exitosamente');
} catch (loadError) {
console.error(`[DLL] ✗ Error cargando DLL: ${loadError.message}`);
console.error(`[DLL] Stack trace: ${loadError.stack}`);
// Diagnóstico del error
if (loadError.message.includes('Failed to load shared library')) {
console.log('[DLL] ℹ Error de dependencias detectado');
// Verificar dependencias del sistema
const dependencyChecks = [
'C:/Windows/System32/msvcr120.dll',
'C:/Windows/System32/msvcp120.dll',
'C:/Windows/System32/vcruntime140.dll',
'C:/Windows/System32/msvcp140.dll',
'C:/Windows/System32/vcruntime140_1.dll',
'C:/Windows/System32/api-ms-win-crt-runtime-l1-1-0.dll'
];
console.log('[DLL] Verificando dependencias del sistema...');
const missingDeps = [];
for (const dep of dependencyChecks) {
try {
if (fs.existsSync(dep)) {
console.log(`[DLL] ✓ Dependencia encontrada: ${dep}`);
} else {
console.log(`[DLL] ✗ Dependencia faltante: ${dep}`);
missingDeps.push(path.basename(dep));
}
} catch (e) {
console.log(`[DLL] ⚠ Error verificando ${dep}: ${e.message}`);
}
}
let errorMessage = 'No se pudo cargar la librería AutoIt debido a dependencias faltantes.\n\n';
if (missingDeps.length > 0) {
errorMessage += `Dependencias faltantes: ${missingDeps.join(', ')}\n\n`;
}
errorMessage += 'Por favor instala:\n' +
'1. Visual C++ Redistributable 2015-2022 (x64)\n' +
'2. Visual C++ Redistributable 2013 (x64)\n' +
'3. Windows Universal C Runtime\n\n' +
'Enlaces de descarga:\n' +
'- https://aka.ms/vs/17/release/vc_redist.x64.exe\n' +
'- https://www.microsoft.com/download/details.aspx?id=40784\n\n' +
'Reinicia la aplicación después de la instalación.';
dialog.showErrorBox('Error - Dependencias AutoIt', errorMessage);
}
throw loadError;
}
// Resto del código AS400...
console.log('[SETUP] Configuración de AutoIt completada, continuando con AS400...');
} catch (error) {
console.error(`[ERROR] ✗ Error crítico en AS400 Launcher: ${error.message}`);
const { dialog } = require('electron');
dialog.showErrorBox('Error - AutoIt',
`Error cargando AutoIt: ${error.message}\n\n` +
'Por favor reporta este error al desarrollador.'
);
throw error;
}
// Verificar las rutas de los ejecutables
const as400LauncherPath = 'C:/Users/Public/IBM/ClientSolutions/Start_Programs/Windows_i386-32/acslaunch_win-32.exe';
const as400ConfigPath = 'C:/RpaClaro/AS400.hod';
console.log(`[EXEC] Verificando ejecutable AS400: ${as400LauncherPath}`);
if (!fs.existsSync(as400LauncherPath)) {
console.log('[EXEC] ✗ ERROR: No se encontró el ejecutable AS400');
dialog.showErrorBox('Error - AS400',
`No se encontró el ejecutable AS400 en:\n${as400LauncherPath}\n\n` +
'Por favor verifica que IBM Client Solutions esté instalado.'
);
return;
}
console.log(`[EXEC] Verificando configuración AS400: ${as400ConfigPath}`);
if (!fs.existsSync(as400ConfigPath)) {
console.log('[EXEC] ⚠ ADVERTENCIA: No se encontró el archivo de configuración AS400');
}
// Continuar con el resto del código AS400...
console.log('[EXEC] Ejecutando AS400 Launcher...');
console.log(`[EXEC] Comando: ${as400LauncherPath} ${as400ConfigPath}`);
await autoit.run(`"${as400LauncherPath}" "${as400ConfigPath}"`);
console.log('[EXEC] ✓ Comando ejecutado, esperando ventana...');
console.log('[WAIT] Esperando ventana "Iniciar sesión en IBM i" (timeout: 35s)...');
const result = await autoit.winWait("Iniciar sesión en IBM i", "", 35);
if (result) {
console.log('[WINDOW] ✓ Ventana "Iniciar sesión en IBM i" detectada');
let ventana_error = 0;
let ventana_contrasena = 0;
let ventana_mensaje1 = 0;
let ventana_mensaje2 = 0;
console.log("El programa se ha abierto correctamente.");
console.log('[INPUT] Activando ventana y enviando credenciales...');
await autoit.winActivate("Iniciar sesión en IBM i");
await autoit.winSetState("A - ", '', 3)
await autoit.winSetState("A - ", '', 3);
console.log(`[INPUT] Enviando usuario: ${usuario}`);
await autoit.controlSend("Iniciar sesión en IBM i", '', null, usuario);
await autoit.winActivate("Iniciar sesión en IBM i");
console.log('[INPUT] Enviando TAB');
await autoit.controlSend("Iniciar sesión en IBM i", '', null, "{TAB}");
await autoit.winActivate("Iniciar sesión en IBM i");
console.log('[INPUT] Enviando contraseña');
await autoit.controlSend("Iniciar sesión en IBM i", '', null, password);
console.log('[INPUT] Enviando ENTER para login');
await autoit.controlSend("Iniciar sesión en IBM i", '', null, "{ENTER}");
console.log('[WAIT] Verificando mensaje de error (timeout: 8s)...');
ventana_error = await autoit.winWait("Mensaje de error", "", 8);
if (ventana_error == 1) {
console.log("Aparecio mensaje de error");
console.log('[ERROR] ✗ Apareció mensaje de error, presionando ENTER para continuar');
await autoit.controlSend("Mensaje de error", '', null, "{ENTER}");
} else {
console.log("No aparecio mensaje de error");
console.log('[ERROR] ✓ No apareció mensaje de error');
}
console.log('[WAIT] Verificando error de credenciales (timeout: 35s)...');
const ventana_login_error = await autoit.winWait("Iniciar sesión en IBM i", "", 35);
if (ventana_login_error) {
console.log('[LOGIN] ✗ Error de credenciales detectado');
console.log('[CLEANUP] Cerrando ventanas...');
await autoit.winClose("Iniciar sesión en IBM i");
await autoit.winClose("A - ");
console.log('[DIALOG] Mostrando dialog de error al usuario');
dialog.showErrorBox('Error', 'Parece que hubo un problema con el ingreso. Por favor, repórtalo al Coordinador');
} else {
console.log('[LOGIN] ✓ No hay error de credenciales');
}
console.log('[WAIT] Verificando cambio de contraseña (timeout: 1s)...');
ventana_contrasena = await autoit.winWait("Cambiar contraseña de IBM i", "", 1);
if (ventana_contrasena == 1) {
console.log("Aparecio mensaje de contrasena");
console.log('[PASSWORD] ⚠ Apareció solicitud de cambio de contraseña');
} else {
console.log("No aparecio mensaje de contrasena");
console.log('[PASSWORD] ✓ No hay solicitud de cambio de contraseña');
}
console.log('[WAIT] Verificando mensaje de consulta 1 (timeout: 1s)...');
ventana_mensaje1 = await autoit.winWait("Mensaje de consulta", "", 1);
if (ventana_mensaje1 == 1) {
console.log('[MSG1] ✓ Apareció mensaje de consulta 1, presionando ENTER');
await autoit.controlSend("Mensaje de consulta", '', null, "{ENTER}");
console.log("Aparecio mensaje 1");
} else {
console.log("No aparecio mensaje 1");
console.log('[MSG1] ✓ No apareció mensaje de consulta 1');
}
console.log('[WAIT] Verificando mensaje de consulta 2 (timeout: 1s)...');
ventana_mensaje2 = await autoit.winWait("Mensaje de consulta", "", 1);
if (ventana_mensaje2 == 1) {
console.log('[MSG2] ✓ Apareció mensaje de consulta 2, presionando ENTER');
await autoit.controlSend("Mensaje de consulta", '', null, "{ENTER}");
console.log("Aparecio mensaje 2");
} else {
console.log("No aparecio mensaje 2");
console.log('[MSG2] ✓ No apareció mensaje de consulta 2');
}
console.log(ventana_contrasena);
console.log(ventana_error);
console.log(`[STATUS] Estado ventana_contrasena: ${ventana_contrasena}`);
console.log(`[STATUS] Estado ventana_error: ${ventana_error}`);
if (ventana_contrasena == 0 && ventana_error == 0) {
console.log('diferentes');
console.log('[SECOND_LOGIN] Condiciones para segundo login cumplidas');
console.log('[DELAY] Esperando 3 segundos...');
await new Promise((resolve) => setTimeout(resolve, 3000));
console.log('[WINDOW] Obteniendo texto de ventana "A - "');
let segundo_login = await autoit.winGetText('A - ');
console.log(segundo_login);
console.log(`[WINDOW] Texto obtenido: ${segundo_login}`);
if (segundo_login == 128) {
console.log('Se encontro segundo login');
console.log('[SECOND_LOGIN] ✓ Se encontró segundo login');
await autoit.winActivate("A - ");
console.log('[DELAY] Esperando 2 segundos adicionales...');
await new Promise((resolve) => setTimeout(resolve, 2000));
try {
console.log('[HOTKEY] Ejecutando hotkey Shift+Ctrl+W');
await autoit.controlSend("A - ", '', null, "+^w");
console.log('Se ejecuto hotkey');
console.log('[HOTKEY] ✓ Hotkey ejecutado exitosamente');
console.log(`[INPUT] Enviando usuario en segundo login: ${usuario}`);
await autoit.controlSend("A - ", '', null, usuario);
await autoit.winActivate("A - ");
console.log('[INPUT] Enviando TAB en segundo login');
await autoit.controlSend("A - ", '', null, "{TAB}");
await autoit.winActivate("A - ");
console.log('[INPUT] Enviando contraseña en segundo login');
await autoit.controlSend("A - ", '', null, password);
console.log('[INPUT] Enviando ENTER para segundo login');
await autoit.controlSend("A - ", '', null, "{ENTER}");
} catch (error) {
console.log('No se ejecuto hotkey: ' + error);
console.log(`[HOTKEY] ✗ Error ejecutando hotkey: ${error}`);
}
} else {
console.log('No se encontro segundo login');
console.log('[SECOND_LOGIN] ✓ No se encontró segundo login necesario');
}
}
console.log('[AS400] ✓ Proceso AS400 completado exitosamente');
} else {
console.log("El programa no se ha abierto dentro del tiempo de espera.");
console.log('[TIMEOUT] ✗ El programa no se abrió dentro del tiempo de espera (35s)');
}
} catch (error) {
console.error("Error:", error);
console.error(`[ERROR] ✗ Error crítico en AS400 Launcher: ${error.message}`);
console.error(`[ERROR] Stack trace: ${error.stack}`);
throw error;
}
}
runAS400Launcher();
console.log('[ASYNC] Iniciando proceso asíncrono AS400...');
// Envolver en try-catch para manejar promesas rechazadas
runAS400Launcher().catch(error => {
console.error(`[PROMISE] ✗ Error en promesa AS400: ${error.message}`);
});
console.log('[RETURN] Función rr() completada, retornando "test"');
return 'test';
}
module.exports = { rr };
// Funciones auxiliares (mantener las existentes)
function verificarYEliminarArchivo(nombreArchivo) {
console.log(`[FILE] Verificando existencia del archivo: ${nombreArchivo}`);
if (fs.existsSync(nombreArchivo)) {
try {
// fs.unlinkSync(nombreArchivo); // Descomentar para eliminar el archivo
console.log(`[FILE] ✓ Archivo encontrado y eliminado: '${nombreArchivo}'`);
} catch (e) {
console.log(`[FILE] ✗ Error al eliminar el archivo '${nombreArchivo}': ${e}`);
}
} else {
console.log(`[FILE] ℹ El archivo '${nombreArchivo}' no existe.`);
}
}
function generarArchivo(nombreArchivo, contenido) {
console.log(`[FILE] Generando archivo de macro: ${nombreArchivo}`);
console.log(`[FILE] Tamaño del contenido: ${contenido.length} caracteres`);
try {
fs.writeFileSync(nombreArchivo, contenido, 'utf8');
console.log(`[FILE] ✓ Archivo generado exitosamente: '${nombreArchivo}'`);
} catch (e) {
console.log(`[FILE] ✗ Error al generar el archivo '${nombreArchivo}': ${e}`);
}
}
function checkSystemArchitecture() {
const arch = os.arch();
const platform = os.platform();
console.log(`[SYSTEM] Arquitectura: ${arch}`);
console.log(`[SYSTEM] Plataforma: ${platform}`);
return arch;
}
module.exports = { rr };