app-min-ser-nest/src/modules/reportes/reportes.service.ts
2026-10-22 22:03:27 -04:00

993 lines
32 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import {
BadRequestException,
ForbiddenException,
Injectable,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { randomUUID } from 'node:crypto';
import { existsSync, mkdirSync, createWriteStream } from 'node:fs';
import { join } from 'node:path';
import PDFDocument from 'pdfkit';
import { Repository } from 'typeorm';
import {
EstadoAsistencia,
EstadoGeneral,
EstadoMiembro,
EstadoServicio,
} from '../../common/enums/estados.enum.js';
import { Autorizacion, Rol } from '../../common/enums/rol.enum.js';
import {
AuthUser,
isDeveloper,
isSuperAdmin,
} from '../../common/utils/auth-user.js';
import {
defaultServiceResult,
ServiceResult,
} from '../../common/interfaces/service.result.js';
import { Persona } from '../persona/entities/persona.entity.js';
import { Reporte } from './entities/reporte.entity.js';
import { TipoReporte } from './dto/reporte.dto.js';
/** Fila cruda de los reportes (JSON para el front, base de las tablas PDF). */
type Fila = Record<string, unknown>;
interface Col {
header: string;
width: number;
get: (fila: Fila) => string;
}
interface EncabezadoControl {
/** Nombre(s) del equipo (convención: uno por servicio). */
equipo: string;
/** Nombre del servicio (REUNIÓN). */
reunion: string;
/** Fecha larga: "25 de Oct. de 2026". */
fecha: string;
}
interface DatosReporte {
titulo: string;
columnas: Col[];
filas: Fila[];
/** Solo el reporte por servicio: servidores marcados en esta corrida. */
inhabilitados?: Fila[];
/** Solo asistencia-servicio: encabezado "CONTROL DE ASISTENCIA" (Letter). */
control?: EncabezadoControl;
}
const ESTADOS_REALIZADO = [
EstadoServicio.Publicado,
EstadoServicio.EnCurso,
EstadoServicio.Finalizado,
];
const MESES_CORTOS = [
'Ene.',
'Feb.',
'Mar.',
'Abr.',
'May.',
'Jun.',
'Jul.',
'Ago.',
'Sep.',
'Oct.',
'Nov.',
'Dic.',
];
@Injectable()
export class ReportesService {
constructor(
@InjectRepository(Persona)
private readonly personaRepository: Repository<Persona>,
@InjectRepository(Reporte)
private readonly reporteRepository: Repository<Reporte>,
) {}
// ---------------------------------------------------------------- acceso
/** Developer (bypass) y SuperAdmin ven todo; solo el Líder ve reportes. */
private validarAcceso(user: AuthUser | null): void {
if (isDeveloper(user) || isSuperAdmin(user)) return;
if (user?.rol !== Rol.Lider) {
throw new ForbiddenException(
'Solo Developer, SuperAdmin o Líder pueden generar reportes.',
);
}
}
/** `null` = sin scoping (Developer/SuperAdmin); si no, equipos activos del líder. */
private async equiposScope(user: AuthUser | null): Promise<string[] | null> {
if (isDeveloper(user) || isSuperAdmin(user)) return null;
const rows: { idEquipo: string }[] =
await this.personaRepository.manager.query(
`SELECT "idEquipo" FROM equipo_persona
WHERE "idPersona" = $1 AND estado = $2`,
[user?.idPersona, EstadoMiembro.Activo],
);
return rows.map((r) => r.idEquipo);
}
private validarRango(desde?: string, hasta?: string): void {
const iso = /^\d{4}-\d{2}-\d{2}$/;
if (!desde || !iso.test(desde) || !hasta || !iso.test(hasta)) {
throw new BadRequestException(
'Rango de fechas inválido: usá el formato YYYY-MM-DD (desde y hasta).',
);
}
if (desde > hasta) {
throw new BadRequestException(
'El rango de fechas es inválido (desde > hasta).',
);
}
}
// ------------------------------------------------------------ reportes
async asistenciaPorServicio(
idServicio: string | undefined,
user: AuthUser | null,
idEquipo?: string,
): Promise<ServiceResult> {
this.validarAcceso(user);
if (!idServicio) {
throw new BadRequestException('Falta el parámetro idServicio.');
}
const manager = this.personaRepository.manager;
const servicioRows: Fila[] = await manager.query(
`SELECT "idServicio", nombre,
to_char(fecha, 'YYYY-MM-DD') AS fecha,
estado
FROM servicio
WHERE "idServicio" = $1 AND estado <> $2`,
[idServicio, EstadoServicio.Eliminado],
);
if (!servicioRows.length) {
throw new BadRequestException('No existe el servicio.');
}
// Convocados con su nombre (para el selector de equipo del front).
const convocados: Fila[] = await manager.query(
`SELECT se."idEquipo", e."nombreEquipo"
FROM servicio_equipo se
JOIN equipo e ON e."idEquipo" = se."idEquipo"
WHERE se."idServicio" = $1
ORDER BY e."nombreEquipo"`,
[idServicio],
);
// Scoping Líder: solo sus equipos (membresía Activa ∩ convocados).
let equipos: string[] | null = await this.equiposScope(user);
if (equipos !== null) {
const set = new Set(equipos);
equipos = convocados
.map((c) => c.idEquipo as string)
.filter((id) => set.has(id));
if (!equipos.length) {
throw new ForbiddenException(
'Solo el líder de un equipo convocado del servicio puede ver el reporte.',
);
}
}
// Selector de equipo (un equipo o "Todos"): si viene idEquipo debe ser
// uno de los convocados (y del scoping del líder).
const convocadoSet = new Set(convocados.map((c) => c.idEquipo as string));
if (idEquipo) {
if (!convocadoSet.has(idEquipo)) {
throw new BadRequestException(
'El equipo no está convocado en el servicio.',
);
}
if (equipos !== null && !equipos.includes(idEquipo)) {
throw new ForbiddenException('No podés ver reportes de ese equipo.');
}
}
// Título del reporte: un equipo → "Equipo X - Reporte"; Todos →
// "Ministerio Ser - Reporte".
const nombreEquipoSel = idEquipo
? (convocados.find((c) => c.idEquipo === idEquipo)
?.nombreEquipo as string)
: null;
const titulo = nombreEquipoSel
? `${nombreEquipoSel} - Reporte`
: 'Ministerio Ser - Reporte';
const turnos: Fila[] = await manager.query(
`SELECT t.nombre,
t.tipo,
t."horaInicio",
t."horaFin",
st.sec
FROM servicio_turno st
JOIN turno t ON t."idTurno" = st."idTurno"
WHERE st."idServicio" = $1
ORDER BY st.sec`,
[idServicio],
);
const paramsFilas: unknown[] = [idServicio];
let whereFilas = 'a."idServicio" = $1';
if (idEquipo) {
paramsFilas.push(idEquipo);
whereFilas += ' AND a."idEquipo" = $2';
} else if (equipos !== null) {
paramsFilas.push(`{${equipos.join(',')}}`);
whereFilas += ' AND a."idEquipo" = ANY($2::uuid[])';
}
const filas: Fila[] = await manager.query(
`SELECT a."idAsistencia",
p."idPersona",
p.nombres,
p.apellidos,
p.nombres || ' ' || p.apellidos AS persona,
p.rol,
p.estado AS "estadoPersona",
e."nombreEquipo" AS equipo,
a.estado,
a."fecIngreso" IS NOT NULL AS "tieneIngreso",
to_char(a."fecIngreso", 'HH24:MI DD-MM-YYYY') AS ingreso,
to_char(a."fecSalida", 'HH24:MI DD-MM-YYYY') AS salida,
a.observacion
FROM asistencia a
JOIN persona p ON p."idPersona" = a."idPersona"
JOIN equipo e ON e."idEquipo" = a."idEquipo"
WHERE ${whereFilas}
ORDER BY e."nombreEquipo", p.apellidos, p.nombres`,
paramsFilas,
);
// Subrutina de la tanda: servidores activos sin ingreso en 3 meses
// calendario → Inhabilitado (solo al generar este reporte). No es un
// bloqueo: la persona sigue pudiendo entrar y marcar (rehabilita sola).
const inhabilitados = await this.evaluarInhabilitados();
// `equiposVisibles` acota el selector del front al scoping del líder.
const equiposVisibles =
equipos === null
? convocados
: convocados.filter((c) => equipos!.includes(c.idEquipo as string));
return this.ok(
titulo,
filas,
{
...servicioRows[0],
titulo,
equipos: equiposVisibles,
turnos,
filas,
},
inhabilitados,
);
}
async asistenciaPorPersona(
desde: string | undefined,
hasta: string | undefined,
user: AuthUser | null,
idEquipo?: string,
idPersona?: string,
): Promise<ServiceResult> {
this.validarAcceso(user);
this.validarRango(desde, hasta);
const scope = await this.equiposScope(user);
const filtros: string[] = [
's.estado = ANY($1)',
's.fecha >= $2::date',
's.fecha <= $3::date',
];
const params: unknown[] = [
`{${ESTADOS_REALIZADO.join(',')}}`,
desde,
hasta,
];
if (scope !== null) {
filtros.push('a."idEquipo" = ANY($4::uuid[])');
params.push(`{${scope.join(',')}}`);
}
if (idEquipo) {
params.push(idEquipo);
filtros.push(`a."idEquipo" = $${params.length}`);
}
if (idPersona) {
params.push(idPersona);
filtros.push(`a."idPersona" = $${params.length}`);
}
const filas: Fila[] = await this.personaRepository.manager.query(
`SELECT p."idPersona",
p.nombres || ' ' || p.apellidos AS persona,
p.rol,
p.estado AS "estadoPersona",
COUNT(*)::int AS convocados,
COUNT(*) FILTER (WHERE a.estado IN ('Presente','Atrasado'))::int AS ingresados,
COUNT(*) FILTER (WHERE a.estado = 'Presente')::int AS presentes,
COUNT(*) FILTER (WHERE a.estado = 'Atrasado')::int AS atrasados,
COUNT(*) FILTER (WHERE a.estado = 'Permiso')::int AS permisos,
COUNT(*) FILTER (WHERE a.estado = 'Falta')::int AS faltas,
COUNT(*) FILTER (WHERE a.estado = 'Pendiente')::int AS pendientes
FROM asistencia a
JOIN persona p ON p."idPersona" = a."idPersona"
JOIN servicio s ON s."idServicio" = a."idServicio"
WHERE ${filtros.join(' AND ')}
GROUP BY p."idPersona", p.nombres, p.apellidos, p.rol, p.estado
ORDER BY (COUNT(*) FILTER (WHERE a.estado IN ('Presente','Atrasado'))::float
/ NULLIF(COUNT(*), 0)) DESC, persona`,
params,
);
return this.ok('Reporte de asistencia por persona.', filas, {
desde,
hasta,
idEquipo,
idPersona,
});
}
async resumenPorEquipo(
desde: string | undefined,
hasta: string | undefined,
user: AuthUser | null,
): Promise<ServiceResult> {
this.validarAcceso(user);
this.validarRango(desde, hasta);
const scope = await this.equiposScope(user);
const filtros: string[] = [
's.estado = ANY($1)',
's.fecha >= $2::date',
's.fecha <= $3::date',
];
const params: unknown[] = [
`{${ESTADOS_REALIZADO.join(',')}}`,
desde,
hasta,
];
if (scope !== null) {
filtros.push('a."idEquipo" = ANY($4::uuid[])');
params.push(`{${scope.join(',')}}`);
}
const filas: Fila[] = await this.personaRepository.manager.query(
`SELECT e."idEquipo",
e."nombreEquipo" AS equipo,
COUNT(*)::int AS convocados,
COUNT(*) FILTER (WHERE a.estado IN ('Presente','Atrasado'))::int AS ingresados,
COUNT(*) FILTER (WHERE a.estado = 'Atrasado')::int AS atrasados,
COUNT(*) FILTER (WHERE a.estado = 'Permiso')::int AS permisos,
COUNT(*) FILTER (WHERE a.estado = 'Falta')::int AS faltas,
COUNT(*) FILTER (WHERE a.estado = 'Pendiente')::int AS pendientes
FROM asistencia a
JOIN equipo e ON e."idEquipo" = a."idEquipo"
JOIN servicio s ON s."idServicio" = a."idServicio"
WHERE ${filtros.join(' AND ')}
GROUP BY e."idEquipo", e."nombreEquipo"
ORDER BY (COUNT(*) FILTER (WHERE a.estado IN ('Presente','Atrasado'))::float
/ NULLIF(COUNT(*), 0)) DESC, e."nombreEquipo"`,
params,
);
return this.ok('Reporte resumen por equipo.', filas, { desde, hasta });
}
async faltasPermisos(
desde: string | undefined,
hasta: string | undefined,
user: AuthUser | null,
idEquipo?: string,
): Promise<ServiceResult> {
this.validarAcceso(user);
this.validarRango(desde, hasta);
const scope = await this.equiposScope(user);
const filtros: string[] = [
`a.estado IN ('Falta','Permiso')`,
's.estado = ANY($1)',
's.fecha >= $2::date',
's.fecha <= $3::date',
];
const params: unknown[] = [
`{${ESTADOS_REALIZADO.join(',')}}`,
desde,
hasta,
];
if (scope !== null) {
filtros.push('a."idEquipo" = ANY($4::uuid[])');
params.push(`{${scope.join(',')}}`);
}
if (idEquipo) {
filtros.push(`a."idEquipo" = $${params.length + 1}`);
params.push(idEquipo);
}
const filas: Fila[] = await this.personaRepository.manager.query(
`SELECT to_char(s.fecha, 'YYYY-MM-DD') AS fecha,
s.nombre AS servicio,
p.nombres || ' ' || p.apellidos AS persona,
e."nombreEquipo" AS equipo,
a.estado,
COALESCE(a.observacion, '') AS observacion
FROM asistencia a
JOIN persona p ON p."idPersona" = a."idPersona"
JOIN equipo e ON e."idEquipo" = a."idEquipo"
JOIN servicio s ON s."idServicio" = a."idServicio"
WHERE ${filtros.join(' AND ')}
ORDER BY s.fecha DESC, e."nombreEquipo", p.apellidos`,
params,
);
return this.ok('Reporte de faltas y permisos.', filas, {
desde,
hasta,
idEquipo,
});
}
async atrasos(
desde: string | undefined,
hasta: string | undefined,
user: AuthUser | null,
): Promise<ServiceResult> {
this.validarAcceso(user);
this.validarRango(desde, hasta);
const scope = await this.equiposScope(user);
const filtros: string[] = [
's.estado = ANY($1)',
's.fecha >= $2::date',
's.fecha <= $3::date',
];
const params: unknown[] = [
`{${ESTADOS_REALIZADO.join(',')}}`,
desde,
hasta,
];
if (scope !== null) {
filtros.push('a."idEquipo" = ANY($4::uuid[])');
params.push(`{${scope.join(',')}}`);
}
const filas: Fila[] = await this.personaRepository.manager.query(
`SELECT p."idPersona",
p.nombres || ' ' || p.apellidos AS persona,
string_agg(DISTINCT e."nombreEquipo", ', ' ORDER BY e."nombreEquipo") AS equipo,
COUNT(*) FILTER (WHERE a.estado = 'Atrasado')::int AS atrasados,
COUNT(*)::int AS convocados
FROM asistencia a
JOIN persona p ON p."idPersona" = a."idPersona"
JOIN equipo e ON e."idEquipo" = a."idEquipo"
JOIN servicio s ON s."idServicio" = a."idServicio"
WHERE ${filtros.join(' AND ')}
GROUP BY p."idPersona", p.nombres, p.apellidos
HAVING COUNT(*) FILTER (WHERE a.estado = 'Atrasado') > 0
ORDER BY atrasados DESC, persona`,
params,
);
return this.ok('Reporte de atrasos.', filas, { desde, hasta });
}
// ------------------------------------------------------- inhabilitados
/**
* Servidores con membresía activa, `estado = Activo` y **cero ingresos**
* (Presente/Atrasado con `fecIngreso`) en los últimos 3 meses calendario
* → pasan a `Inhabilitado`. Devuelve los marcados en esta corrida.
*/
private async evaluarInhabilitados(): Promise<Fila[]> {
const manager = this.personaRepository.manager;
const candidatos: Fila[] = await manager.query(
`SELECT p."idPersona",
p.nombres || ' ' || p.apellidos AS persona,
p.whatsapp
FROM persona p
WHERE p.rol = $1
AND p.estado = $2
AND p.autorizacion = $6
AND EXISTS (
SELECT 1 FROM equipo_persona ep
WHERE ep."idPersona" = p."idPersona"
AND ep.estado = $3
)
AND NOT EXISTS (
SELECT 1 FROM asistencia a
WHERE a."idPersona" = p."idPersona"
AND a."fecIngreso" IS NOT NULL
AND a.estado IN ($4, $5)
AND a."fecIngreso" >= now() - interval '3 months'
)`,
[
Rol.Servidor,
EstadoGeneral.Activo,
EstadoMiembro.Activo,
EstadoAsistencia.Presente,
EstadoAsistencia.Atrasado,
Autorizacion.Usuario,
],
);
if (!candidatos.length) return [];
const ids = candidatos.map((c) => c.idPersona as string);
await manager.query(
`UPDATE persona SET estado = $1 WHERE "idPersona" = ANY($2::uuid[])`,
[EstadoGeneral.Inhabilitado, `{${ids.join(',')}}`],
);
return candidatos;
}
// ---------------------------------------------------------------- PDF
/** Exporta el reporte a PDF en `uploads/reportes/` y registra el link. */
async generarPdf(
tipo: TipoReporte,
parametros: Record<string, unknown> | undefined,
user: AuthUser | null,
): Promise<ServiceResult> {
this.validarAcceso(user);
const p = parametros ?? {};
let datos: DatosReporte;
switch (tipo) {
case 'asistencia-servicio':
datos = await this.datosAsistenciaServicio(
p.idServicio as string,
user,
p.idEquipo as string | undefined,
);
break;
case 'asistencia-persona':
datos = this.extraer(
tipo,
await this.asistenciaPorPersona(
p.desde as string,
p.hasta as string,
user,
p.idEquipo as string | undefined,
p.idPersona as string | undefined,
),
);
break;
case 'resumen-equipo':
datos = this.extraer(
tipo,
await this.resumenPorEquipo(
p.desde as string,
p.hasta as string,
user,
),
);
break;
case 'faltas-permisos':
datos = this.extraer(
tipo,
await this.faltasPermisos(
p.desde as string,
p.hasta as string,
user,
p.idEquipo as string | undefined,
),
);
break;
case 'atrasos':
datos = this.extraer(
tipo,
await this.atrasos(p.desde as string, p.hasta as string, user),
);
break;
default:
throw new ForbiddenException('Tipo de reporte inválido.');
}
const idPersona = (user?.idPersona ?? '') as string;
const generadoPor = await this.personaRepository.findOneBy({
idPersona,
});
const nombreGenerado = generadoPor
? `${generadoPor.nombres} ${generadoPor.apellidos}`
: 'Sistema';
const dir = join(process.cwd(), 'uploads', 'reportes');
mkdirSync(dir, { recursive: true });
const archivo = `${new Date().toISOString().slice(0, 10)}-${tipo}-${randomUUID()}.pdf`;
const rutaRel = `uploads/reportes/${archivo}`;
const url = `/uploads/reportes/${archivo}`;
await this.renderPdf(dir, archivo, datos, nombreGenerado);
const fila = await this.reporteRepository.save({
tipo,
parametros: p,
rutaArchivo: rutaRel,
generadoPor: idPersona,
});
const serviceResult = defaultServiceResult();
serviceResult.boolean = true;
serviceResult.message = 'PDF generado correctamente.';
serviceResult.number = 1;
serviceResult.object = {
idReporte: fila.idReporte,
url,
titulo: datos.titulo,
filas: datos.filas.length,
};
return serviceResult;
}
/** Convierte el ServiceResult de un GET en los datos para renderizar. */
private extraer(tipo: TipoReporte, result: ServiceResult): DatosReporte {
return {
titulo: result.message,
columnas: this.columnasDe(tipo),
filas: result.data ?? [],
};
}
private ok(
message: string,
filas: Fila[],
objeto: Record<string, unknown>,
inhabilitados?: Fila[],
): ServiceResult {
const serviceResult = defaultServiceResult();
serviceResult.boolean = true;
serviceResult.message = message;
serviceResult.number = filas.length;
serviceResult.data = filas;
serviceResult.object = {
...objeto,
titulo: message,
filas,
inhabilitados: inhabilitados ?? [],
};
return serviceResult;
}
// El método de datos por servicio se separa para poder reutilizarlo en el
// PDF con su side-effect de inhabilitados incluido.
private async datosAsistenciaServicio(
idServicio: string | undefined,
user: AuthUser | null,
idEquipo?: string,
): Promise<DatosReporte> {
const result = await this.asistenciaPorServicio(idServicio, user, idEquipo);
const objeto = result.object as {
nombre?: string;
fecha?: string;
equipos?: { nombreEquipo?: string }[];
};
// Numeración para la columna "N" del CONTROL DE ASISTENCIA.
const filas = (result.data ?? []).map((f, i) => ({ ...f, n: i + 1 }));
// EQUIPO del encabezado: el de las filas (con idEquipo filtrado ya vienen
// solo de ese equipo); sin filas, los equipos visibles (convocados).
const porFilas = [
...new Set(
filas
.map((f) => (f.equipo == null ? '' : String(f.equipo)))
.filter((v) => v !== ''),
),
];
const nombres =
porFilas.length > 0
? porFilas
: (objeto.equipos ?? []).map((e) => e.nombreEquipo ?? '');
return {
// `result.message` ya es el título calculado ("Equipo X - Reporte" o
// "Ministerio Ser - Reporte"); se le agrega el detalle del servicio.
titulo:
`${result.message} — ${objeto.nombre ?? ''} (${objeto.fecha ?? ''})`.trim(),
columnas: this.columnasDe('asistencia-servicio'),
filas,
control: {
equipo: nombres.filter(Boolean).join(' · ') || '—',
reunion: objeto.nombre ?? '',
fecha: this.fechaTexto(objeto.fecha),
},
};
}
/** "2026-10-21" → "21 de Oct. de 2026" (encabezado del reporte Letter). */
private fechaTexto(iso?: string): string {
const partes = (iso ?? '').split('-');
if (partes.length !== 3) return '—';
const [anio, mes, dia] = partes;
const mesTxt = MESES_CORTOS[Number(mes) - 1];
if (!mesTxt) return '—';
return `${Number(dia)} de ${mesTxt} de ${anio}`;
}
/** Definición de columnas de cada reporte para la tabla del PDF. */
private columnasDe(tipo: TipoReporte | string): Col[] {
const str = (v: unknown) => (v == null ? '' : String(v));
const hora = (v: unknown) => str(v) || '—';
const pct = (ing: unknown, conv: unknown) =>
Number(conv) > 0
? `${((Number(ing) * 100) / Number(conv)).toFixed(1)}%`
: '—';
switch (tipo) {
// CONTROL DE ASISTENCIA (Letter): N | NOMBRES | APELLIDOS | INGRESO |
// SALIDA | ASISTENCIA (estado de la asistencia, texto de la DB) |
// ESTADO (persona.estado en mayúsculas). Suma 532pt = Letter - márgenes.
case 'asistencia-servicio':
return [
{ header: 'N', width: 26, get: (f) => str(f.n) },
{ header: 'NOMBRES', width: 92, get: (f) => str(f.nombres) },
{ header: 'APELLIDOS', width: 92, get: (f) => str(f.apellidos) },
{ header: 'INGRESO', width: 96, get: (f) => hora(f.ingreso) },
{ header: 'SALIDA', width: 96, get: (f) => hora(f.salida) },
{ header: 'ASISTENCIA', width: 66, get: (f) => str(f.estado) },
{
header: 'ESTADO',
width: 64,
get: (f) => str(f.estadoPersona).toUpperCase(),
},
];
case 'asistencia-persona':
return [
{ header: 'Persona', width: 150, get: (f) => str(f.persona) },
{ header: 'Conv.', width: 45, get: (f) => str(f.convocados) },
{ header: 'Ing.', width: 45, get: (f) => str(f.ingresados) },
{ header: 'Atraso', width: 50, get: (f) => str(f.atrasados) },
{ header: 'Permiso', width: 55, get: (f) => str(f.permisos) },
{ header: 'Falta', width: 45, get: (f) => str(f.faltas) },
{ header: 'Pend.', width: 50, get: (f) => str(f.pendientes) },
{
header: '% asist.',
width: 60,
get: (f) => pct(f.ingresados, f.convocados),
},
];
case 'resumen-equipo':
return [
{ header: 'Equipo', width: 150, get: (f) => str(f.equipo) },
{ header: 'Conv.', width: 50, get: (f) => str(f.convocados) },
{ header: 'Ing.', width: 50, get: (f) => str(f.ingresados) },
{ header: 'Atraso', width: 55, get: (f) => str(f.atrasados) },
{ header: 'Permiso', width: 60, get: (f) => str(f.permisos) },
{ header: 'Falta', width: 50, get: (f) => str(f.faltas) },
{
header: '% asist.',
width: 70,
get: (f) => pct(f.ingresados, f.convocados),
},
];
case 'faltas-permisos':
return [
{ header: 'Fecha', width: 70, get: (f) => str(f.fecha) },
{ header: 'Servicio', width: 120, get: (f) => str(f.servicio) },
{ header: 'Persona', width: 140, get: (f) => str(f.persona) },
{ header: 'Equipo', width: 90, get: (f) => str(f.equipo) },
{ header: 'Estado', width: 60, get: (f) => str(f.estado) },
{ header: 'Observación', width: 90, get: (f) => str(f.observacion) },
];
case 'atrasos':
return [
{ header: 'Persona', width: 150, get: (f) => str(f.persona) },
{ header: 'Equipo', width: 130, get: (f) => str(f.equipo) },
{ header: 'Atrasos', width: 60, get: (f) => str(f.atrasados) },
{ header: 'Conv.', width: 50, get: (f) => str(f.convocados) },
{
header: '% atraso',
width: 70,
get: (f) => pct(f.atrasados, f.convocados),
},
];
default:
return [{ header: 'Datos', width: 300, get: (f) => JSON.stringify(f) }];
}
}
/** Escribe el PDF (pdfkit) y resuelve al terminar el stream. */
private renderPdf(
dir: string,
archivo: string,
datos: DatosReporte,
generadoPor: string,
): Promise<void> {
return new Promise((resolve, reject) => {
const doc = new PDFDocument({
margin: 40,
// Los 5 reportes van en tamaño Carta (tanda 2026-10-22).
size: 'LETTER',
bufferPages: true,
});
const stream = createWriteStream(join(dir, archivo));
stream.on('finish', () => resolve());
stream.on('error', reject);
doc.pipe(stream);
const cols = datos.columnas;
const left = doc.page.margins.left;
const usable = doc.page.width - left - doc.page.margins.right;
let y: number;
if (datos.control) {
// --- CONTROL DE ASISTENCIA (Letter): logos + título + campos. ---
y = doc.page.margins.top;
const hLogo = 34;
const rutaSer = join(process.cwd(), 'assets', 'logo-ser.png');
const rutaEk = join(process.cwd(), 'assets', 'logo-ekklesia.png');
if (existsSync(rutaSer)) {
doc.image(rutaSer, left, y, { height: hLogo });
}
if (existsSync(rutaEk)) {
// logo-ekklesia.png mide 1920×600 (relación 3.2): alineado a la
// derecha del área útil.
const wEk = Math.round(hLogo * (1920 / 600));
doc.image(rutaEk, left + usable - wEk, y, { height: hLogo });
}
doc
.font('Helvetica-Bold')
.fontSize(16)
.fillColor('#000000')
.text('CONTROL DE ASISTENCIA', left, y + 9, {
width: usable,
align: 'center',
});
// Campos: EQUIPO (izq.) · REUNIÓN (centro) · FECHA (der.); la
// etiqueta va en negrita y el valor se trunca con "…" si no cabe.
const yCampos = y + hLogo + 10;
const campo = (
x: number,
w: number,
alin: 'left' | 'center' | 'right',
etiqueta: string,
valor: string,
): void => {
doc.font('Helvetica-Bold').fontSize(10);
const lw = doc.widthOfString(`${etiqueta}: `);
doc.font('Helvetica');
let v = valor || '—';
while (v.length > 1 && lw + doc.widthOfString(`${v}…`) > w) {
v = v.slice(0, -1);
}
if (lw + doc.widthOfString(v) > w) v = '…';
const xTxt =
alin === 'left'
? x
: alin === 'right'
? x + w - (lw + doc.widthOfString(v))
: x + (w - (lw + doc.widthOfString(v))) / 2;
doc.font('Helvetica-Bold').text(`${etiqueta}: `, xTxt, yCampos, {
lineBreak: false,
});
doc.font('Helvetica').text(v, xTxt + lw, yCampos, {
lineBreak: false,
});
};
const tercio = Math.floor(usable / 3);
campo(left, tercio, 'left', 'EQUIPO', datos.control.equipo);
campo(
left + tercio,
tercio,
'center',
'REUNIÓN',
datos.control.reunion,
);
campo(
left + 2 * tercio,
usable - 2 * tercio,
'right',
'FECHA',
datos.control.fecha,
);
doc
.moveTo(left, yCampos + 16)
.lineTo(left + usable, yCampos + 16)
.strokeColor('#999999')
.lineWidth(0.75)
.stroke();
y = yCampos + 24;
doc.font('Helvetica').fontSize(9).fillColor('#000000');
} else {
// Los otros 4 reportes: solo el título dinámico (sin "Generado por"
// ni "Filtros"; el pie se dibuja al final de cada página).
doc.font('Helvetica').fontSize(14).text(datos.titulo, {
align: 'center',
});
doc.moveDown(1);
y = doc.y;
}
const rowHeight = 16;
const dibujarHeader = () => {
doc.font('Helvetica-Bold').fontSize(9);
let x = left;
doc
.rect(
left,
y,
cols.reduce((a, c) => a + c.width, 0),
rowHeight,
)
.fill('#e8eef7');
doc.fillColor('#000000');
for (const c of cols) {
doc.text(c.header, x + 3, y + 4, {
width: c.width - 6,
ellipsis: true,
});
x += c.width;
}
y += rowHeight;
doc.font('Helvetica').fontSize(9);
};
dibujarHeader();
for (const fila of datos.filas) {
if (y > doc.page.height - doc.page.margins.bottom - rowHeight) {
doc.addPage();
y = doc.page.margins.top;
dibujarHeader();
}
let x = left;
for (const c of cols) {
doc.text(c.get(fila), x + 3, y + 4, {
width: c.width - 6,
height: rowHeight - 4,
ellipsis: true,
lineBreak: false,
});
x += c.width;
}
doc
.moveTo(left, y + rowHeight)
.lineTo(left + cols.reduce((a, c) => a + c.width, 0), y + rowHeight)
.strokeColor('#dddddd')
.lineWidth(0.5)
.stroke();
y += rowHeight;
}
if (!datos.filas.length) {
doc
.moveDown(1)
.text(
datos.control
? 'Sin asistencias registradas.'
: '(sin filas para el rango/filtros elegidos)',
{ align: 'center' },
);
}
// Pie de cada página: quién lo generó, fecha/hora y "Página X de Y".
// bufferedPageRange() ya incluye todas las páginas (también la actual);
// el y debe quedar dentro del área útil (height - 50), porque si excede
// maxY() pdfkit agrega una página nueva en vez de dibujar el pie.
const rango = doc.bufferedPageRange();
const total = rango.count;
const generado = `Generado por: ${generadoPor} · ${new Date().toLocaleString('es-BO', { timeZone: 'America/La_Paz' })}`;
for (let i = rango.start; i < rango.start + rango.count; i++) {
doc.switchToPage(i);
doc
.fontSize(8)
.fillColor('#777777')
.text(
`${generado} · Página ${i - rango.start + 1} de ${total}`,
doc.page.margins.left,
doc.page.height - 50,
{
width:
doc.page.width - doc.page.margins.left - doc.page.margins.right,
align: 'center',
},
);
doc.fillColor('#000000');
}
doc.end();
});
}
}