autoWebClic.js

///////////////////////////////////////////////////
//           INICIAR EL PROGRAMA                 //
///////////////////////////////////////////////////
console.log(`################################################################`);
console.log(`############### autoWebClic v.  1 . 0 . 1 #######################`);
console.log(`################################################################`);
console.log(`Iniciando ejecución`);
const puppeteer = require('puppeteer');
// const fs = require('fs');


// Parámetros configurables
// const MAX_INTENTOS_FALLIDOS = 5; // Máximo de fallos consecutivos permitidos


// Función para registrar información en un archivo
/* function registrarEnArchivo(mensaje) {
    const timestamp = new Date().toISOString();
    const logMessage = `[${timestamp}] ${mensaje}\n`;
    fs.appendFileSync('registro_ejecucionesTOTAL.log', logMessage, 'utf8');
	console.log(logMessage.trim());
} */
// DEFINIR PAUSAS

 // MARCA DE TIEMPO PARA CALCULAR TIEMPO DE EJECUCIÓN TOTAL 
 
// const inicioScript = new Date(); // Marca de tiempo inicial

// FUNCIÓN PRINCIPAL ASÍNCRONA

async function ejecutarScript() {
	const inicio = Date.now();
//	console.log(`El programa se va a ejecutar ${repetitions} veces`);
	
try {
    // Navegar a la página de inicio de sesión
	const browser = await puppeteer.launch({
		headless: true, // true ejecuta el programa en modo oculto - false para visualizar
		protocolTimeout: 120000, // Incrementa el tiempo de espera
//		dumpio: true, // Imprime más detalles en la consola
	});	
	const esperar = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); 
	const esperaInicio = Math.floor(Math.random() * 5000) + 5000; // Entre 5 y 10 segundos	
	const page = await browser.newPage();
	console.log(`Abriendo navegador`);
    await page.goto('tu-pagina-de-inicio-de-sesion', { timeout: 120000 });
	await esperar(esperaInicio); // Pausa
	
	console.log(`Ingresando credenciales`);
    // Ingresar las credenciales
    const usuario = 'tu-usuario'; // Reemplaza con tu usuario
    const contrasena = 'tu-contraseña'; // Reemplaza con tu contraseña

    // Completar los campos de usuario y contraseña
    await page.type('#id-del-elemento-de-usuario', usuario); // Selector del campo de usuario
    await page.type('#id-del-elemento-de-contraseña', contrasena); // Selector del campo de contraseña

    // Hacer clic en el botón de inicio de sesión
    await page.click('id-del-boton-de-iniciar-sesion'); // Selector del botón de inicio de sesión

    // Esperar la navegación después del inicio de sesión
	await esperar(esperaInicio); // Pausa

    console.log(`Inicio de sesión exitoso.`);
	
// NÚMERO DE ITERACIONES DE CADA ASIGNATURA
		const repetitions = 500 // 100
		const A = 70; // 70
		const B = 65; // 65
		const C = 64; // 64
		const D = 58; // 58

	// A
	for (let i = 0; i < repetitions; i++) {
		const esperaAleatoria = Math.floor(Math.random() * 2000) + 3000; // Entre 4 y 6 segundos
		console.log(`Tiempo de espera definido en ${(esperaAleatoria) / 1000} segundos`);
		console.log(`A`);
		console.log(`Iniciando vuelta número: ${i + 1} de ${repetitions}`);
		await page.goto('pagina1', { timeout: 120000 });

		for (let i = 0; i < A; i++) {
			await page.waitForSelector('#id-boton-siguiente-pagina', { visible: true, timeout: 120000 });
			await page.click('#id-boton-siguiente-pagina');
			await esperar(esperaAleatoria);
			console.log(`Página: ${i + 1} de ${A}`);
		}
	console.log(`A exitoso. ${i + 1} vueltas`);
	}

	// B
	for (let i = 0; i < repetitions; i++) {
		const esperaAleatoria = Math.floor(Math.random() * 2000) + 3000; // Entre 4 y 6 segundos
		console.log(`Tiempo de espera definido en ${(esperaAleatoria) / 1000} segundos`);
		console.log(`B`);
		console.log(`Iniciando vuelta número: ${i + 1} de ${repetitions}`);
	    await page.goto('pagina1', { timeout: 120000 });
		
		for (let i = 0; i < B; i++) {
			await page.waitForSelector('#id-boton-siguiente-pagina', { visible: true, timeout: 120000 });
			await page.click('#id-boton-siguiente-pagina');
			await esperar(esperaAleatoria);
			console.log(`Página: ${i + 1} de ${B}`);
			}
	console.log(`B exitoso. ${i + 1} vueltas`);
	}

    // C
   for (let i = 0; i < repetitions; i++) {
		const esperaAleatoria = Math.floor(Math.random() * 2000) + 3000; // Entre 4 y 6 segundos
		console.log(`Tiempo de espera definido en ${(esperaAleatoria) / 1000} segundos`);
		console.log(`C`);
		console.log(`Iniciando vuelta número: ${i + 1} de ${repetitions}`);
		await page.goto('pagina1', { timeout: 120000 });
		for (let i = 0; i < C; i++) {
			await page.waitForSelector('#id-boton-siguiente-pagina', { visible: true, timeout: 120000 });
			await page.click('#id-boton-siguiente-pagina');
			await esperar(esperaAleatoria); 
			console.log(`Página: ${i + 1} de ${C}`);
			}
	console.log(`C exitoso. ${i + 1} vueltas`);
	}

    // D
   for (let i = 0; i < repetitions; i++) {
		const esperaAleatoria = Math.floor(Math.random() * 2000) + 3000; // Entre 4 y 6 segundos
		console.log(`Tiempo de espera definido en ${(esperaAleatoria) / 1000} segundos`);
		console.log(`D`);
		console.log(`Iniciando vuelta número: ${i + 1} de ${repetitions}`);
		await page.goto('pagina1', { timeout: 120000 });
		for (let i = 0; i < D; i++) {
			await page.waitForSelector('#id-boton-siguiente-pagina', { visible: true, timeout: 120000 });
			await page.click('#id-boton-siguiente-pagina');
			await esperar(esperaAleatoria);
			console.log(`Página: ${i + 1} de ${D}`);
		}
	console.log(`D exitoso. ${i + 1} vueltas`);
	}

	console.log(`${repetitions} vueltas al temario completadas`);
	
// LOGOUT
	await page.waitForSelector('#user-menu-toggle', { visible: true, timeout: 120000 });
	await page.goto('tu-pagina-de-logout', { timeout: 120000 });
	const esperaAleatoria = Math.floor(Math.random() * 2000) + 3000; // Entre 4 y 6 segundos
	console.log(`Tiempo de espera definido en ${(esperaAleatoria) / 1000} segundos`);
	await esperar(esperaAleatoria); 
	
/* // MARCA DE TIEMPO FINAL Y CÁLCULO DE TIEMPO TOTAL DE EJECUCIÓN

	const fin = new Date(); // Marca de tiempo final
	const tiempoEjecucionTotal = (fin - inicioScript); // Tiempo de ejecución en ms
		const horas = Math.floor(tiempoEjecucionTotal / (1000 * 60 * 60));
		const minutos = Math.floor((tiempoEjecucionTotal % (1000 * 60 * 60)) / (1000 * 60));
		const segundos = Math.floor((tiempoEjecucionTotal % (1000 * 60)) / 1000);
	console.log(`Tiempo total de ejecución total: ${horas}h ${minutos}m ${segundos}s`); */

// MARCA DE TIEMPO INTENTO Y CÁLCULO DE TIEMPO DE EJECUCIÓN DEL INTENTO
 //	const tiempoEjecucion = ((Date.now() - inicio) / 1000).toFixed(2);
        console.log(`Ejecución finalizada correctamente en ${tiempoEjecucion} segundos.`);
//        registrarEnArchivo(`Ejecución finalizada correctamente en ${tiempoEjecucion} segundos.`);
	
 //       return true; // Indica éxito 
	} catch (error) {
//        const tiempoEjecucion = ((Date.now() - inicio) / 1000).toFixed(2);
        console.error('Error durante la ejecución:', error.message);
//        registrarEnArchivo(`Error: ${error.message}. Tiempo de ejecución: ${tiempoEjecucion} segundos.`);
 //       await new Promise((resolve) => setTimeout(resolve, 5000)); // Espera antes de reiniciar
		const TIEMPO_REINICIO = 120000; // Tiempo en ms antes de reiniciar tras cada intento
		await new Promise(resolve => setTimeout(resolve, TIEMPO_REINICIO));
		console.log(`Reiniciando tras errores...`);
        ejecutarScript(); // Llamada recursiva para reiniciar
	}
	console.log(`Fin del script.`);
	console.log(`Reiniciando...`);
}	
// registrarEnArchivo('Iniciando programa...');

ejecutarScript();

 /* (async () => {
    let intentosFallidos = 0;

    while (true) {
        console.log('Iniciando nueva ejecución del script...');
 //       registrarEnArchivo('Iniciando nueva ejecución.');

        const exito = await ejecutarScript();

        if (exito) {
            intentosFallidos = 0; // Reinicia el contador tras un intento exitoso
        } else {
            intentosFallidos++;
            console.log(`Intentos fallidos consecutivos: ${intentosFallidos}`);
//            registrarEnArchivo(`Intentos fallidos consecutivos: ${intentosFallidos}`);
        }

/*         if (intentosFallidos >= MAX_INTENTOS_FALLIDOS) {
            console.error(`Se alcanzó el máximo de ${MAX_INTENTOS_FALLIDOS} intentos fallidos. Deteniendo.`);
            registrarEnArchivo(`Se alcanzó el máximo de ${MAX_INTENTOS_FALLIDOS} intentos fallidos. Deteniendo.`);
            break;
        } */

        // Espera antes de reiniciar
  //      console.log(`Esperando ${TIEMPO_REINICIO / 1000} segundos antes de reiniciar...`);
 //       registrarEnArchivo(`Esperando ${TIEMPO_REINICIO / 1000} segundos antes de reiniciar.`);
 //       await new Promise(resolve => setTimeout(resolve, TIEMPO_REINICIO));
 //   } 
 //} */
/*     console.log('Bucle finalizado.');
    registrarEnArchivo('Bucle finalizado.');  */
/* })(); */