363 lines
13 KiB
JavaScript
363 lines
13 KiB
JavaScript
// worker-multi-estado.js (V9 - ADAPTADOR PARA TU APP + FECHA CONTACTO AUTO)
|
|
'use strict';
|
|
|
|
const { chromium } = require('playwright');
|
|
const admin = require('firebase-admin');
|
|
|
|
// --- CONFIGURACIÓN ---
|
|
const CONFIG = {
|
|
QUEUE_COLLECTION: 'multiasistencia_cambios_estado',
|
|
RESULT_COLLECTION: 'multiasistencia_cambios_estado_log',
|
|
MULTI_LOGIN: "https://web.multiasistencia.com/w3multi/acceso.php",
|
|
MULTI_ACTION_BASE: "https://web.multiasistencia.com/w3multi/fechaccion.php",
|
|
NAV_TIMEOUT: 60000,
|
|
RESCAN_SECONDS: 60
|
|
};
|
|
|
|
// --- UTILS ---
|
|
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
|
|
|
|
function toServerTimestamp() {
|
|
return admin.firestore.FieldValue.serverTimestamp();
|
|
}
|
|
|
|
function timeToMultiValue(timeStr) {
|
|
if (!timeStr) return "";
|
|
const [h, m] = timeStr.split(':').map(Number);
|
|
// Para el desplegable principal (segundos desde medianoche)
|
|
return String((h * 3600) + (m * 60));
|
|
}
|
|
|
|
// Helper: Extraer hora de un texto (Ej: "cita a las 13:00") -> "13:00"
|
|
function extractTimeFromText(text) {
|
|
if (!text) return null;
|
|
const match = text.match(/(\d{1,2}:\d{2})/);
|
|
return match ? match[1] : null;
|
|
}
|
|
|
|
// Helper: Convertir DD/MM/YYYY a YYYY-MM-DD
|
|
function normalizeDate(dateStr) {
|
|
if (!dateStr) return "";
|
|
// Si ya viene como YYYY-MM-DD, devolver tal cual
|
|
if (dateStr.match(/^\d{4}-\d{2}-\d{2}$/)) return dateStr;
|
|
|
|
// Si viene como DD/MM/YYYY
|
|
if (dateStr.includes('/')) {
|
|
const [day, month, year] = dateStr.split('/');
|
|
return `${year}-${month}-${day}`;
|
|
}
|
|
return dateStr;
|
|
}
|
|
|
|
// Obtener fecha y hora actuales desglosadas (Sistema)
|
|
function getCurrentDateTime() {
|
|
const now = new Date();
|
|
const year = now.getFullYear();
|
|
const month = String(now.getMonth() + 1).padStart(2, '0');
|
|
const day = String(now.getDate()).padStart(2, '0');
|
|
|
|
const dateStr = `${year}-${month}-${day}`;
|
|
const hourStr = String(now.getHours());
|
|
const minStr = String(now.getMinutes()).padStart(2, '0');
|
|
|
|
return { dateStr, hourStr, minStr };
|
|
}
|
|
|
|
// --- FIREBASE INIT ---
|
|
function initFirebase() {
|
|
if (!process.env.FIREBASE_PRIVATE_KEY) throw new Error('Missing FIREBASE_PRIVATE_KEY');
|
|
|
|
if (!admin.apps.length) {
|
|
admin.initializeApp({
|
|
credential: admin.credential.cert({
|
|
projectId: process.env.FIREBASE_PROJECT_ID,
|
|
clientEmail: process.env.FIREBASE_CLIENT_EMAIL,
|
|
privateKey: process.env.FIREBASE_PRIVATE_KEY.replace(/\\n/g, '\n'),
|
|
}),
|
|
});
|
|
}
|
|
return admin.firestore();
|
|
}
|
|
|
|
// --- LOGIN ---
|
|
async function loginMulti(page, db) {
|
|
let user = "", pass = "";
|
|
const doc = await db.collection("providerCredentials").doc("multiasistencia").get();
|
|
|
|
if (doc.exists) {
|
|
user = doc.data().user;
|
|
pass = doc.data().pass;
|
|
}
|
|
|
|
if (!user) throw new Error("Faltan credenciales en providerCredentials/multiasistencia");
|
|
|
|
console.log('🔐 Login en Multiasistencia...');
|
|
await page.goto(CONFIG.MULTI_LOGIN, { timeout: 60000, waitUntil: 'domcontentloaded' });
|
|
|
|
const userFilled = await page.evaluate((u) => {
|
|
const el = document.querySelector('input[name="usuario"]') || document.querySelector('input[type="text"]');
|
|
if (el) {
|
|
el.value = u;
|
|
el.dispatchEvent(new Event('input', { bubbles: true }));
|
|
return true;
|
|
}
|
|
return false;
|
|
}, user);
|
|
|
|
if (!userFilled) await page.fill('input[name="usuario"]', user);
|
|
await page.fill('input[type="password"]', pass);
|
|
await page.click('input[type="submit"]');
|
|
await page.waitForTimeout(4000);
|
|
}
|
|
|
|
// --- PLAYWRIGHT SETUP ---
|
|
async function withBrowser(fn) {
|
|
const browser = await chromium.launch({ headless: true, args: ['--no-sandbox'] });
|
|
const context = await browser.newContext();
|
|
const page = await context.newPage();
|
|
try { return await fn(page); } finally { await browser.close().catch(() => {}); }
|
|
}
|
|
|
|
async function forceUpdate(elementHandle) {
|
|
if (elementHandle) {
|
|
await elementHandle.evaluate(el => {
|
|
el.dispatchEvent(new Event('input', { bubbles: true }));
|
|
el.dispatchEvent(new Event('change', { bubbles: true }));
|
|
el.dispatchEvent(new Event('blur', { bubbles: true }));
|
|
});
|
|
}
|
|
}
|
|
|
|
// --- LÓGICA PRINCIPAL ---
|
|
async function processChangeState(page, db, jobData) {
|
|
// --- ADAPTADOR DE DATOS (MAPPING) ---
|
|
// Tu App envía 'nuevoEstado', 'observaciones', 'fecha' (DD/MM/YYYY)
|
|
|
|
const serviceNumber = jobData.serviceNumber;
|
|
|
|
// 1. Mapear Motivo
|
|
const reasonValue = jobData.reasonValue || jobData.nuevoEstado || jobData.estado;
|
|
|
|
// 2. Mapear Comentario
|
|
const comment = jobData.comment || jobData.observaciones || jobData.nota;
|
|
|
|
// 3. Mapear y Normalizar Fecha (DD/MM/YYYY -> YYYY-MM-DD)
|
|
const rawDate = jobData.dateStr || jobData.fecha;
|
|
const dateStr = normalizeDate(rawDate);
|
|
|
|
// 4. Mapear Hora (Intentar buscar en timeStr, o extraer de la nota)
|
|
let timeStr = jobData.timeStr || extractTimeFromText(comment);
|
|
|
|
console.log(`🔧 DATOS PROCESADOS: ID:${reasonValue} | Fecha:${dateStr} | Hora:${timeStr}`);
|
|
|
|
// VALIDACIÓN
|
|
if (!reasonValue || reasonValue === 'undefined') {
|
|
throw new Error("DATOS FALTANTES: No se encontró 'nuevoEstado' ni 'reasonValue' en Firebase.");
|
|
}
|
|
|
|
// -----------------------------------------------------------
|
|
|
|
// 1. LOGIN
|
|
await loginMulti(page, db);
|
|
|
|
// 2. IR AL SERVICIO
|
|
const targetUrl = `${CONFIG.MULTI_ACTION_BASE}?reparacion=${serviceNumber}&modo=0&navid=%2Fw3multi%2Ffrepasos_new.php%FDGET%FDrefresh%3D1%FC`;
|
|
console.log(`📂 Abriendo servicio ${serviceNumber}...`);
|
|
await page.goto(targetUrl, { waitUntil: 'domcontentloaded', timeout: 60000 });
|
|
|
|
await page.waitForSelector('select.answer-select', { timeout: 20000 });
|
|
await page.waitForTimeout(1500);
|
|
console.log('📝 Rellenando formulario...');
|
|
|
|
// 3. MOTIVO
|
|
const reasonSel = page.locator('select.answer-select').first();
|
|
const targetValue = String(reasonValue);
|
|
|
|
// Diagnóstico rápido
|
|
const availableOptions = await reasonSel.evaluate((select) => {
|
|
return Array.from(select.options).map(o => ({ value: o.value, text: o.innerText.trim() }));
|
|
});
|
|
const optionExists = availableOptions.find(o => o.value === targetValue);
|
|
|
|
if (!optionExists) {
|
|
const validList = availableOptions.map(o => `[${o.value}: ${o.text}]`).join(', ');
|
|
throw new Error(`MOTIVO INVÁLIDO: El ID "${targetValue}" no existe. Opciones: ${validList}`);
|
|
}
|
|
|
|
await reasonSel.selectOption(targetValue);
|
|
await forceUpdate(await reasonSel.elementHandle());
|
|
|
|
// 4. COMENTARIO
|
|
if (comment) {
|
|
const commentBox = page.locator('textarea[formcontrolname="comment"]');
|
|
await commentBox.fill(comment);
|
|
await forceUpdate(await commentBox.elementHandle());
|
|
}
|
|
|
|
// 5. FECHA SIGUIENTE ACCIÓN (Solo si hay fecha futura)
|
|
if (dateStr) {
|
|
// Bloque TXTFACCION (preferido)
|
|
const actionBlock = page.locator('encastrables-date-hour-field[label="TXTFACCION"]');
|
|
|
|
if (await actionBlock.count() > 0) {
|
|
const dateInput = actionBlock.locator('input[type="date"]');
|
|
await dateInput.fill(dateStr);
|
|
await forceUpdate(await dateInput.elementHandle());
|
|
await page.click('body');
|
|
|
|
// Hora (Solo si la hemos detectado)
|
|
if (timeStr) {
|
|
const secondsValue = timeToMultiValue(timeStr);
|
|
const timeSelect = actionBlock.locator('select.answer-select');
|
|
// Intentamos seleccionar, si falla (ej: hora no válida) no rompemos el flujo
|
|
await timeSelect.selectOption(secondsValue).catch(() => console.log(`⚠️ Hora ${timeStr} no válida en desplegable`));
|
|
await forceUpdate(await timeSelect.elementHandle());
|
|
}
|
|
} else {
|
|
// Fallback genérico
|
|
const genericDateInput = page.locator('input[type="date"]').first();
|
|
await genericDateInput.fill(dateStr);
|
|
await forceUpdate(await genericDateInput.elementHandle());
|
|
}
|
|
}
|
|
|
|
// 6. HISTÓRICO / FECHA CONTACTO (AUTOMÁTICO - SIEMPRE HOY)
|
|
const contactBlock = page.locator('encastrables-date-hour-field[label="TXTFCONTACTO"]');
|
|
|
|
if (await contactBlock.count() > 0 && await contactBlock.isVisible()) {
|
|
console.log('📞 Rellenando "Fecha contacto cliente" con FECHA ACTUAL...');
|
|
const now = getCurrentDateTime();
|
|
|
|
// Fecha
|
|
const contactDateInput = contactBlock.locator('input[type="date"]');
|
|
await contactDateInput.fill(now.dateStr);
|
|
await forceUpdate(await contactDateInput.elementHandle());
|
|
|
|
// Hora y Minutos
|
|
const selects = contactBlock.locator('select.answer-select-time');
|
|
if (await selects.count() >= 2) {
|
|
await selects.nth(0).selectOption(now.hourStr).catch(() => {});
|
|
await forceUpdate(await selects.nth(0).elementHandle());
|
|
|
|
await selects.nth(1).selectOption(now.minStr).catch(() => {});
|
|
await forceUpdate(await selects.nth(1).elementHandle());
|
|
}
|
|
}
|
|
|
|
await page.waitForTimeout(2000);
|
|
|
|
// 7. GUARDAR
|
|
const btn = page.locator('button.form-container-button-submit');
|
|
|
|
if (await btn.isDisabled()) {
|
|
console.log('⛔ Botón deshabilitado. Reintentando...');
|
|
await page.click('textarea[formcontrolname="comment"]');
|
|
await page.keyboard.press('Tab');
|
|
await page.waitForTimeout(1000);
|
|
if (await btn.isDisabled()) throw new Error(`IMPOSIBLE GUARDAR: Formulario bloqueado.`);
|
|
}
|
|
|
|
console.log('💾 Click en Guardar...');
|
|
await btn.click();
|
|
|
|
// 8. ALERTAS
|
|
await page.waitForTimeout(3000);
|
|
const confirmBtn = page.locator('button.form-container-button-submit-toast').filter({ hasText: 'Sí' });
|
|
if (await confirmBtn.count() > 0 && await confirmBtn.isVisible()) {
|
|
console.log('🚨 ALERTA SMS. Confirmando...');
|
|
await confirmBtn.click();
|
|
await page.waitForTimeout(3000);
|
|
}
|
|
|
|
// 9. VERIFICACIÓN
|
|
const screenshotBuffer = await page.screenshot({ fullPage: true, quality: 50, type: 'jpeg' });
|
|
const screenshotBase64 = screenshotBuffer.toString('base64');
|
|
|
|
const finalResult = await page.evaluate(() => {
|
|
const successEl = document.querySelector('.form-container-success') || document.querySelector('.bg-success');
|
|
const errorEl = document.querySelector('.form-container-error') || document.querySelector('.bg-danger');
|
|
if (successEl) return { type: 'OK', text: successEl.innerText };
|
|
if (errorEl) return { type: 'ERROR', text: errorEl.innerText };
|
|
return { type: 'UNKNOWN', text: document.body.innerText.substring(0, 300) };
|
|
});
|
|
|
|
console.log(`🏁 RESULTADO: [${finalResult.type}]`);
|
|
|
|
return {
|
|
success: (finalResult.type === 'OK' || finalResult.text.includes('correctamente')),
|
|
message: finalResult.text,
|
|
screenshot: screenshotBase64
|
|
};
|
|
}
|
|
|
|
// --- WORKER LOOP ---
|
|
async function claimJobById(db, jobId) {
|
|
const ref = db.collection(CONFIG.QUEUE_COLLECTION).doc(jobId);
|
|
return await db.runTransaction(async (tx) => {
|
|
const snap = await tx.get(ref);
|
|
if (!snap.exists || snap.data().status !== 'PENDING') return null;
|
|
tx.set(ref, { status: 'RUNNING', claimedAt: toServerTimestamp() }, { merge: true });
|
|
return { id: jobId, ...snap.data() };
|
|
});
|
|
}
|
|
|
|
async function markJobDone(db, job, result) {
|
|
const jobId = job.id;
|
|
await db.collection(CONFIG.QUEUE_COLLECTION).doc(jobId).set({ status: 'DONE', result }, { merge: true });
|
|
|
|
await db.collection(CONFIG.RESULT_COLLECTION).add({
|
|
jobId,
|
|
ok: true,
|
|
serviceNumber: job.serviceNumber || '',
|
|
reason: job.nuevoEstado || job.estado || '', // Adaptado al log
|
|
comment: job.observaciones || job.nota || '', // Adaptado al log
|
|
...result,
|
|
createdAt: toServerTimestamp()
|
|
});
|
|
}
|
|
|
|
async function markJobFailed(db, job, err) {
|
|
const jobId = job.id;
|
|
await db.collection(CONFIG.QUEUE_COLLECTION).doc(jobId).set({
|
|
status: 'FAILED',
|
|
error: { message: err.message }
|
|
}, { merge: true });
|
|
|
|
await db.collection(CONFIG.RESULT_COLLECTION).add({
|
|
jobId,
|
|
ok: false,
|
|
serviceNumber: job.serviceNumber || '',
|
|
error: err.message,
|
|
createdAt: toServerTimestamp()
|
|
});
|
|
}
|
|
|
|
async function processJob(db, job) {
|
|
console.log(`>>> Procesando Job: ${job.id}`);
|
|
try {
|
|
await withBrowser(async (page) => {
|
|
const res = await processChangeState(page, db, job); // Pasamos todo el objeto 'job'
|
|
await markJobDone(db, job, res);
|
|
console.log(`✅ Job ${job.id} Completado.`);
|
|
});
|
|
} catch (err) {
|
|
console.error(`❌ Job ${job.id} Falló:`, err.message);
|
|
await markJobFailed(db, job, err);
|
|
}
|
|
}
|
|
|
|
function startWorker(db) {
|
|
const queue = [];
|
|
const run = async () => {
|
|
while(queue.length) { await processJob(db, await claimJobById(db, queue.shift())); }
|
|
};
|
|
|
|
db.collection(CONFIG.QUEUE_COLLECTION).where('status', '==', 'PENDING').onSnapshot(s => {
|
|
s.docChanges().forEach(c => { if(c.type==='added') { queue.push(c.doc.id); run(); } });
|
|
});
|
|
|
|
console.log('🚀 Worker Multiasistencia (V9 - ADAPTADOR APP) LISTO.');
|
|
}
|
|
|
|
const db = initFirebase();
|
|
startWorker(db); |