Consultoría Alcaraz Salazar
a718592291
- Frontend React (SKEEN Brand) con Vite, TypeScript, Tailwind - Frontend Homenest (versión alternativa) - Módulos Odoo 17 custom (citas, pacientes, monedero, pagos, ventas, inventario, whatsapp) - WACRM fork (Next.js 16 + Supabase) - Hermes + Bridge + Skills (Qwen3.6 via Nan Builders) - Scripts de migración y operación - Documentación extensiva en docs/
518 lines
18 KiB
Python
Executable File
518 lines
18 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
Extracción read-only de datos del sistema legacy SKEEN.
|
|
Uso autorizado por el responsable del proyecto con credenciales proporcionadas.
|
|
Solo lee datos; no modifica nada en https://sistema.skeenmx.app/
|
|
"""
|
|
|
|
import requests
|
|
import csv
|
|
import json
|
|
import re
|
|
import sys
|
|
import time
|
|
from pathlib import Path
|
|
from datetime import datetime, timedelta
|
|
from concurrent.futures import ThreadPoolExecutor, as_completed
|
|
from bs4 import BeautifulSoup
|
|
|
|
BASE = 'https://sistema.skeenmx.app'
|
|
USERNAME = 'JoseSkeen'
|
|
PASSWORD = 'SKr#902_88'
|
|
OUTDIR = Path('/root/migracion/extraccion')
|
|
OUTDIR.mkdir(parents=True, exist_ok=True)
|
|
CACHE = OUTDIR / 'detalle_pacientes.json'
|
|
|
|
session = requests.Session()
|
|
|
|
|
|
def log(msg):
|
|
print(f'[{datetime.now().strftime("%H:%M:%S")}] {msg}')
|
|
|
|
|
|
def login():
|
|
log('Iniciando sesión...')
|
|
r = session.get(f'{BASE}/login', timeout=30)
|
|
r.raise_for_status()
|
|
soup = BeautifulSoup(r.text, 'html.parser')
|
|
token = soup.find('input', {'name': '_token'})
|
|
token = token['value'] if token else ''
|
|
data = {
|
|
'_token': token,
|
|
'username': USERNAME,
|
|
'password': PASSWORD,
|
|
}
|
|
r = session.post(f'{BASE}/login', data=data, timeout=30, allow_redirects=True)
|
|
r.raise_for_status()
|
|
if '/login' in r.url or 'estas credenciales' in r.text.lower():
|
|
raise Exception('Login fallido. Verifica credenciales.')
|
|
log('Login exitoso')
|
|
return True
|
|
|
|
|
|
def dt_params(start=0, length=100, search=''):
|
|
"""Genera parámetros DataTables server-side."""
|
|
return {
|
|
'draw': 1,
|
|
'columns[0][data]': 'id',
|
|
'columns[0][name]': '',
|
|
'columns[0][searchable]': 'true',
|
|
'columns[0][orderable]': 'true',
|
|
'columns[0][search][value]': '',
|
|
'columns[0][search][regex]': 'false',
|
|
'start': start,
|
|
'length': length,
|
|
'search[value]': search,
|
|
'search[regex]': 'false',
|
|
'order[0][column]': '0',
|
|
'order[0][dir]': 'asc',
|
|
'_': int(time.time() * 1000),
|
|
}
|
|
|
|
|
|
def fetch_json(url, params=None):
|
|
headers = {'X-Requested-With': 'XMLHttpRequest'}
|
|
r = session.get(f'{BASE}{url}', params=params or {}, headers=headers, timeout=120)
|
|
r.raise_for_status()
|
|
return r.json()
|
|
|
|
|
|
def paginate(url, params_builder, label, page_size=500, max_pages=None):
|
|
"""Recorre un endpoint DataTables paginado y devuelve todas las filas."""
|
|
log(f'Extrayendo {label} desde {url}...')
|
|
all_rows = []
|
|
start = 0
|
|
page = 0
|
|
while True:
|
|
params = params_builder(start, page_size)
|
|
try:
|
|
data = fetch_json(url, params)
|
|
except Exception as e:
|
|
log(f' ERROR página {page}: {e}')
|
|
break
|
|
rows = data.get('data', [])
|
|
if not rows:
|
|
break
|
|
all_rows.extend(rows)
|
|
total = data.get('recordsTotal') or data.get('recordsFiltered') or 0
|
|
log(f' página {page + 1}: {len(rows)} filas (total acumulado: {len(all_rows)}/{total})')
|
|
if len(rows) < page_size:
|
|
break
|
|
start += page_size
|
|
page += 1
|
|
if max_pages and page >= max_pages:
|
|
break
|
|
time.sleep(0.3)
|
|
log(f'{label}: {len(all_rows)} registros extraídos')
|
|
return all_rows
|
|
|
|
|
|
def save_csv(name, rows, fieldnames):
|
|
path = OUTDIR / f'{name}.csv'
|
|
with open(path, 'w', newline='', encoding='utf-8') as f:
|
|
writer = csv.DictWriter(f, fieldnames=fieldnames, extrasaction='ignore')
|
|
writer.writeheader()
|
|
writer.writerows(rows)
|
|
log(f'Guardado {path}: {len(rows)} registros')
|
|
|
|
|
|
MESES_ES = {
|
|
'enero': '01', 'febrero': '02', 'marzo': '03', 'abril': '04',
|
|
'mayo': '05', 'junio': '06', 'julio': '07', 'agosto': '08',
|
|
'septiembre': '09', 'octubre': '10', 'noviembre': '11', 'diciembre': '12',
|
|
}
|
|
|
|
|
|
def parse_spanish_date(text):
|
|
"""Convierte '05 de Septiembre del 1998' → '1998-09-05'."""
|
|
text = (text or '').strip().lower()
|
|
if not text:
|
|
return ''
|
|
m = re.search(r'(\d{1,2})\s+de\s+([a-záéíóúñ]+)\s+(?:del|de)\s+(\d{4})', text)
|
|
if not m:
|
|
return ''
|
|
dia, mes, anio = m.groups()
|
|
mes_num = MESES_ES.get(mes)
|
|
if not mes_num:
|
|
return ''
|
|
return f'{anio}-{mes_num}-{int(dia):02d}'
|
|
|
|
|
|
def parse_patient_detail(html, fallback_name=''):
|
|
"""Extrae teléfono, email, fecha de nacimiento y sexo del detalle."""
|
|
soup = BeautifulSoup(html, 'html.parser')
|
|
data = {
|
|
'celular': '',
|
|
'whatsapp': '',
|
|
'email': '',
|
|
'fecha_nacimiento': '',
|
|
'sexo': '',
|
|
}
|
|
# Campos de tablas
|
|
for tr in soup.find_all('tr'):
|
|
th = tr.find('th')
|
|
td = tr.find('td')
|
|
if not th or not td:
|
|
continue
|
|
key = ' '.join(th.get_text(strip=True).split()).lower().rstrip(':')
|
|
val = ' '.join(td.get_text(strip=True).split())
|
|
if key == 'celular':
|
|
data['celular'] = re.sub(r'\D', '', val)
|
|
elif key == 'whatsapp':
|
|
data['whatsapp'] = re.sub(r'\D', '', val)
|
|
elif key == 'sexo':
|
|
data['sexo'] = 'female' if 'femenino' in val.lower() else ('male' if 'masculino' in val.lower() else val)
|
|
elif key == 'fecha de nacimiento':
|
|
data['fecha_nacimiento'] = parse_spanish_date(val)
|
|
|
|
# Email suele aparecer como texto suelto o en un mailto
|
|
emails = re.findall(r'[\w.\-]+@[\w.\-]+', soup.get_text())
|
|
if emails:
|
|
data['email'] = emails[0]
|
|
|
|
return data
|
|
|
|
|
|
def load_detail_cache():
|
|
if CACHE.exists():
|
|
try:
|
|
with open(CACHE, 'r', encoding='utf-8') as f:
|
|
return json.load(f)
|
|
except Exception as e:
|
|
log(f'No se pudo cargar caché: {e}')
|
|
return {}
|
|
|
|
|
|
def save_detail_cache(cache):
|
|
with open(CACHE, 'w', encoding='utf-8') as f:
|
|
json.dump(cache, f, ensure_ascii=False, indent=2)
|
|
|
|
|
|
def fetch_one_detail(legacy_id, fallback_name):
|
|
try:
|
|
resp = session.get(f'{BASE}/expediente/ver/{legacy_id}', timeout=30)
|
|
resp.raise_for_status()
|
|
return str(legacy_id), parse_patient_detail(resp.text, fallback_name)
|
|
except Exception as e:
|
|
return str(legacy_id), {'_error': str(e)}
|
|
|
|
|
|
def extract_paciente_details(rows, cache, max_workers=10):
|
|
"""Recorre /expediente/ver/{id} para enriquecer teléfono/email/etc."""
|
|
to_fetch = []
|
|
for r in rows:
|
|
legacy_id = r.get('id')
|
|
if not legacy_id:
|
|
continue
|
|
sid = str(legacy_id)
|
|
# Solo re-extraer si no tenemos teléfono o no está cacheado
|
|
if sid in cache and (cache[sid].get('celular') or cache[sid].get('whatsapp')):
|
|
continue
|
|
to_fetch.append((legacy_id, r.get('nombre', '')))
|
|
|
|
log(f'Extrayendo detalles de {len(to_fetch)} pacientes con {max_workers} workers...')
|
|
total = len(to_fetch)
|
|
completed = 0
|
|
with ThreadPoolExecutor(max_workers=max_workers) as ex:
|
|
future_to_id = {ex.submit(fetch_one_detail, lid, name): lid for lid, name in to_fetch}
|
|
for future in as_completed(future_to_id):
|
|
lid, detail = future.result()
|
|
if '_error' not in detail:
|
|
cache[lid] = detail
|
|
completed += 1
|
|
if completed % 500 == 0:
|
|
log(f' {completed}/{total} detalles procesados')
|
|
save_detail_cache(cache)
|
|
time.sleep(0.01) # pequeña pausa entre completados
|
|
save_detail_cache(cache)
|
|
log('Detalles de pacientes completados')
|
|
|
|
|
|
def extract_expedientes():
|
|
rows = paginate('/expedientes/json', lambda s, l: dt_params(s, l), 'pacientes')
|
|
cache = load_detail_cache()
|
|
extract_paciente_details(rows, cache)
|
|
|
|
out = []
|
|
for r in rows:
|
|
nombre = (r.get('nombre') or '').strip()
|
|
if not nombre or nombre.upper() == '. . NO CITAR':
|
|
continue
|
|
detail = cache.get(str(r.get('id', '')), {})
|
|
# Prioridad: celular > whatsapp > teléfono del listado
|
|
phone = detail.get('celular') or detail.get('whatsapp') or (r.get('telefono') or '').strip()
|
|
# Limpieza: quitar todo excepto dígitos; si empieza con 52 y tiene 12+ dígitos dejarlo, sino agregar prefijo MX si aplica
|
|
phone = re.sub(r'\D', '', phone)
|
|
if phone and not phone.startswith('52') and len(phone) == 10:
|
|
phone = '52' + phone
|
|
email = detail.get('email', '')
|
|
# Algunos correos dummy los ignoramos
|
|
if email.lower() in ('no@no.com', 'no@no'):
|
|
email = ''
|
|
out.append({
|
|
'legacy_id': r.get('id', ''),
|
|
'folio': r.get('folio', ''),
|
|
'nombre': nombre,
|
|
'apellido_paterno': '',
|
|
'apellido_materno': '',
|
|
'telefono': phone,
|
|
'email': email,
|
|
'fecha_nacimiento': detail.get('fecha_nacimiento', ''),
|
|
'sexo': detail.get('sexo', ''),
|
|
'medico_principal': r.get('medico_principal') or '',
|
|
'etiquetas': ','.join(str(c) for c in (r.get('condiciones') or [])) if r.get('condiciones') else '',
|
|
'vip': '1' if r.get('vip') else '0',
|
|
'fuente': 'legacy',
|
|
})
|
|
save_csv('pacientes', out, [
|
|
'legacy_id', 'folio', 'nombre', 'apellido_paterno', 'apellido_materno',
|
|
'telefono', 'email', 'fecha_nacimiento', 'sexo', 'medico_principal',
|
|
'etiquetas', 'vip', 'fuente'
|
|
])
|
|
return out
|
|
|
|
|
|
def extract_monederos():
|
|
rows = paginate('/monederos/json', lambda s, l: dt_params(s, l), 'monederos')
|
|
out = []
|
|
for r in rows:
|
|
saldo = r.get('saldo') or {}
|
|
phone = re.sub(r'\D', '', (r.get('celular') or '').strip())
|
|
if phone and not phone.startswith('52') and len(phone) == 10:
|
|
phone = '52' + phone
|
|
out.append({
|
|
'telefono': phone,
|
|
'puntos': float(saldo.get('mn') or 0),
|
|
'activo': '1' if r.get('activado') else '0',
|
|
})
|
|
save_csv('monederos', out, ['telefono', 'puntos', 'activo'])
|
|
return out
|
|
|
|
|
|
def extract_crm():
|
|
rows = paginate('/crm/prospectos/json', lambda s, l: dt_params(s, l), 'crm prospectos')
|
|
out = []
|
|
for r in rows:
|
|
out.append({
|
|
'nombre': r.get('nombre') or '',
|
|
'folio': r.get('folio') or '',
|
|
'status': r.get('status') or 0,
|
|
'total_citas': r.get('total_citas') or 0,
|
|
'siguiente_cita': r.get('siguiente_cita') or '',
|
|
})
|
|
save_csv('crm_prospectos', out, ['nombre', 'folio', 'status', 'total_citas', 'siguiente_cita'])
|
|
return out
|
|
|
|
|
|
def extract_servicios():
|
|
rows = paginate('/servicios/json', lambda s, l: dt_params(s, l), 'servicios')
|
|
out = []
|
|
for r in rows:
|
|
precio_str = (r.get('precio_minimo') or '0').replace('$', '').replace('m.n.', '').replace(',', '').strip()
|
|
try:
|
|
precio = float(precio_str.split()[0])
|
|
except Exception:
|
|
precio = 0
|
|
out.append({
|
|
'codigo': f"S{r.get('id', 0):04d}",
|
|
'nombre': r.get('servicio') or '',
|
|
'categoria': (r.get('categoria') or '').lower().replace(' ', '_'),
|
|
'precio': precio,
|
|
'duracion_min': 30,
|
|
'descripcion': r.get('grupo_texto') or '',
|
|
'color': r.get('color') or '#1abc9c',
|
|
'grupo': r.get('grupo_texto') or '',
|
|
'favorito': '1' if r.get('favorito') else '0',
|
|
'activo': '1' if r.get('activado') else '0',
|
|
})
|
|
save_csv('servicios', out, [
|
|
'codigo', 'nombre', 'categoria', 'precio', 'duracion_min',
|
|
'descripcion', 'color', 'grupo', 'favorito', 'activo'
|
|
])
|
|
return out
|
|
|
|
|
|
def normalize_phone(phone):
|
|
phone = re.sub(r'\D', '', (phone or ''))
|
|
if phone and not phone.startswith('52') and len(phone) == 10:
|
|
phone = '52' + phone
|
|
return phone
|
|
|
|
|
|
def extract_ventas(start_date='2022-01-01', end_date='2026-07-06'):
|
|
"""Extrae ventas por mes y enriquece con teléfono del paciente."""
|
|
log(f'Extrayendo ventas de {start_date} a {end_date}...')
|
|
# Cargar mapeo legacy_id → teléfono desde pacientes.csv si ya existe
|
|
phone_by_legacy = {}
|
|
pac_path = OUTDIR / 'pacientes.csv'
|
|
if pac_path.exists():
|
|
with open(pac_path, newline='', encoding='utf-8') as f:
|
|
for row in csv.DictReader(f):
|
|
phone_by_legacy[row.get('legacy_id', '')] = row.get('telefono', '')
|
|
|
|
all_rows = []
|
|
current = datetime.strptime(start_date, '%Y-%m-%d').date()
|
|
end = datetime.strptime(end_date, '%Y-%m-%d').date()
|
|
while current <= end:
|
|
chunk_end = min(current + timedelta(days=30), end)
|
|
url = f"/ventas/json/{current.strftime('%Y-%m-%d')}/{chunk_end.strftime('%Y-%m-%d')}"
|
|
try:
|
|
data = fetch_json(url, dt_params(0, 10000))
|
|
rows = data.get('data', [])
|
|
all_rows.extend(rows)
|
|
log(f' {current} - {chunk_end}: {len(rows)} ventas (total: {len(all_rows)})')
|
|
except Exception as e:
|
|
log(f' ERROR {current}-{chunk_end}: {e}')
|
|
current = chunk_end + timedelta(days=1)
|
|
time.sleep(0.5)
|
|
|
|
out = []
|
|
for r in all_rows:
|
|
expediente_id = r.get('expedientes_id') or ''
|
|
phone = normalize_phone(phone_by_legacy.get(str(expediente_id), ''))
|
|
# Servicios vendidos: tomar del primer concepto; si hay varios, crear una línea por concepto
|
|
conceptos = r.get('conceptos') or []
|
|
if not conceptos:
|
|
conceptos = [{'titulo': r.get('motivo') or 'Servicio', 'subtotal': r.get('subtotal') or 0}]
|
|
for c in conceptos:
|
|
precio = 0
|
|
try:
|
|
precio = float(c.get('subtotal') or c.get('pagado') or 0)
|
|
except Exception:
|
|
pass
|
|
out.append({
|
|
'legacy_id': r.get('id', ''),
|
|
'expedientes_id': expediente_id,
|
|
'paciente_telefono': phone,
|
|
'paciente_nombre': r.get('nombre') or '',
|
|
'fecha': (r.get('created_at') or '')[:10],
|
|
'servicio_codigo': '',
|
|
'servicio_nombre': c.get('titulo') or '',
|
|
'cantidad': c.get('cantidad', 1) or 1,
|
|
'precio_unitario': precio,
|
|
'descuento': 0,
|
|
'impuesto': 0,
|
|
'estado': 'confirmed' if not r.get('cancelada') else 'cancelled',
|
|
'notas': r.get('motivo') or '',
|
|
})
|
|
save_csv('ventas', out, [
|
|
'legacy_id', 'expedientes_id', 'paciente_telefono', 'paciente_nombre', 'fecha',
|
|
'servicio_codigo', 'servicio_nombre', 'cantidad', 'precio_unitario',
|
|
'descuento', 'impuesto', 'estado', 'notas'
|
|
])
|
|
return out
|
|
|
|
|
|
def extract_citas(start_date='2022-11-01', end_date='2026-07-06'):
|
|
"""Itera día a día sobre /agenda/citas/YYYY-MM-DD para obtener todas las citas."""
|
|
log(f'Extrayendo citas de {start_date} a {end_date}...')
|
|
phone_by_legacy = {}
|
|
pac_path = OUTDIR / 'pacientes.csv'
|
|
if pac_path.exists():
|
|
with open(pac_path, newline='', encoding='utf-8') as f:
|
|
for row in csv.DictReader(f):
|
|
phone_by_legacy[row.get('legacy_id', '')] = row.get('telefono', '')
|
|
|
|
# Mapeo de IDs de médicos del sistema legacy a nombres (de /agenda)
|
|
medicos_map = {
|
|
'32': 'Dra. Alejandra Ramos',
|
|
'33': 'Dra. Lidia Martinez',
|
|
'46': 'Dra. Fernanda Cerecer',
|
|
'49': 'RODRIGUEZ FRIDA',
|
|
'54': 'Dr. Benjamín Adrián',
|
|
'79': 'XIMENA',
|
|
'80': 'ELY',
|
|
}
|
|
|
|
all_citas = []
|
|
current = datetime.strptime(start_date, '%Y-%m-%d').date()
|
|
end = datetime.strptime(end_date, '%Y-%m-%d').date()
|
|
days_with = 0
|
|
while current <= end:
|
|
url = f"/agenda/citas/{current.strftime('%Y-%m-%d')}"
|
|
try:
|
|
data = fetch_json(url)
|
|
citas = data.get('citas', [])
|
|
if citas:
|
|
days_with += 1
|
|
all_citas.extend(citas)
|
|
if current.day == 1 or len(citas) > 0:
|
|
log(f' {current}: {len(citas)} citas (total acumulado: {len(all_citas)})')
|
|
except Exception as e:
|
|
log(f' ERROR {current}: {e}')
|
|
current += timedelta(days=1)
|
|
time.sleep(0.05)
|
|
|
|
out = []
|
|
for c in all_citas:
|
|
nombre = (c.get('nombre') or '').strip()
|
|
if not nombre or nombre.upper().startswith('. . NO CITAR'):
|
|
continue
|
|
expediente_id = c.get('expedientes_id') or ''
|
|
# El teléfono de la cita suele estar en el registro; si no, buscamos en pacientes
|
|
phone = normalize_phone(c.get('telefono') or phone_by_legacy.get(str(expediente_id), ''))
|
|
if not phone and c.get('whatsapp'):
|
|
phone = normalize_phone(c.get('whatsapp'))
|
|
email = (c.get('correo') or '').strip()
|
|
if email.lower() in ('no@no.com', 'no@no'):
|
|
email = ''
|
|
inicio = c.get('inicio') or ''
|
|
fin = c.get('fin') or ''
|
|
# inicio/fin vienen como '1430' (HHMM)
|
|
hora_str = ''
|
|
if len(inicio) == 4:
|
|
hora_str = f"{inicio[:2]}:{inicio[2:]}"
|
|
elif len(inicio) == 3:
|
|
hora_str = f"0{inicio[0]}:{inicio[1:]}"
|
|
# Nombre del médico
|
|
medico_id = str(c.get('medicos_id') or '')
|
|
doctor_nombre = medicos_map.get(medico_id, medico_id if medico_id and medico_id != '0' else '')
|
|
out.append({
|
|
'legacy_id': c.get('id', ''),
|
|
'expedientes_id': expediente_id,
|
|
'paciente_telefono': phone,
|
|
'paciente_nombre': nombre,
|
|
'servicio_codigo': '',
|
|
'servicio_nombre': c.get('titulo') or '',
|
|
'fecha': c.get('fecha', ''),
|
|
'hora': hora_str,
|
|
'hora_fin': f"{fin[:2]}:{fin[2:]}" if len(fin) == 4 else '',
|
|
'estado': 'confirmed',
|
|
'doctor_nombre': doctor_nombre,
|
|
'sucursal': 'rosarito',
|
|
'medio': 'onsite',
|
|
'notas': c.get('observaciones') or '',
|
|
'estado_pago': 'not_paid',
|
|
'monto_pagado': 0,
|
|
})
|
|
save_csv('citas', out, [
|
|
'legacy_id', 'expedientes_id', 'paciente_telefono', 'paciente_nombre',
|
|
'servicio_codigo', 'servicio_nombre', 'fecha', 'hora', 'hora_fin',
|
|
'estado', 'doctor_nombre', 'sucursal', 'medio', 'notas',
|
|
'estado_pago', 'monto_pagado'
|
|
])
|
|
log(f'Citas: {len(out)} registros útiles en {days_with} días con citas')
|
|
return out
|
|
|
|
|
|
def main():
|
|
try:
|
|
login()
|
|
except Exception as e:
|
|
log(f'ERROR login: {e}')
|
|
sys.exit(1)
|
|
|
|
extract_expedientes()
|
|
extract_monederos()
|
|
extract_crm()
|
|
extract_servicios()
|
|
extract_ventas()
|
|
extract_citas()
|
|
|
|
log('Extracción completada. Archivos en /root/migracion/extraccion/')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|