993 lines
32 KiB
TypeScript
993 lines
32 KiB
TypeScript
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();
|
||
});
|
||
}
|
||
}
|