import { Injectable, Logger, Optional } from '@nestjs/common'; import { InjectRepository } from '@nestjs/typeorm'; import { In, Repository } from 'typeorm'; import { EventsService } from '../../common/services/events.service.js'; import { Servicio } from './entities/servicio.entity.js'; import { ServicioTurno } from '../servicio-turno/entities/servicio-turno.entity.js'; import { ServicioEquipo } from '../servicio-equipo/entities/servicio-equipo.entity.js'; import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js'; import { Turno } from '../turno/entities/turno.entity.js'; import { Equipo } from '../equipo/entities/equipo.entity.js'; import { Asistencia } from '../asistencia/entities/asistencia.entity.js'; import { Configuracion } from '../configuracion/entities/configuracion.entity.js'; import { Reemplazo } from '../reemplazo/entities/reemplazo.entity.js'; import { SolicitudApoyo } from '../solicitud-apoyo/entities/solicitud-apoyo.entity.js'; import { ServicioDto } from './dto/servicio.dto.js'; import { UpdateServicioDto } from './dto/update-servicio.dto.js'; import { CambiarEstadoServicioDto } from './dto/cambiar-estado-servicio.dto.js'; import { defaultServiceResult, ServiceResult, } from '../../common/interfaces/service.result.js'; import { WhereCondition } from '../../common/types/query-builder.types.js'; import { EstadoAsistencia, EstadoConvocatoria, EstadoMiembro, EstadoServicio, } from '../../common/enums/estados.enum.js'; import { TipoAsistencia, MetodoMarcado, } from '../../common/enums/tipos.enum.js'; import { Rol } from '../../common/enums/rol.enum.js'; import { SERVICIO_FIND_WHITELIST, SERVICIO_TRANSICIONES, } from './servicio.constants.js'; import { AuthUser, isDeveloper, isSuperAdmin, } from '../../common/utils/auth-user.js'; @Injectable() export class ServicioService { private readonly logger = new Logger(ServicioService.name); constructor( @InjectRepository(Servicio) private servicioRepository: Repository, @InjectRepository(ServicioTurno) private servicioTurnoRepository: Repository, @InjectRepository(ServicioEquipo) private servicioEquipoRepository: Repository, @InjectRepository(EquipoPersona) private equipoPersonaRepository: Repository, @InjectRepository(Turno) private turnoRepository: Repository, @InjectRepository(Equipo) private equipoRepository: Repository, @InjectRepository(Asistencia) private asistenciaRepository: Repository, @InjectRepository(Configuracion) private configuracionRepository: Repository, @InjectRepository(Reemplazo) private reemplazoRepository: Repository, @InjectRepository(SolicitudApoyo) private solicitudApoyoRepository: Repository, @Optional() private readonly eventsService?: EventsService, ) {} async create( servicioDto: ServicioDto, user: AuthUser, ): Promise { const serviceResult = defaultServiceResult(); // creadoPor siempre desde el JWT (no se confía del body) const creadoPor = user.idPersona; let lat = servicioDto.lat; let lng = servicioDto.lng; if (lat === undefined || lng === undefined) { const config = await this.configuracionRepository.findOneBy({}); lat = lat ?? config?.lat; lng = lng ?? config?.lng; } const entity = this.servicioRepository.create({ nombre: servicioDto.nombre, fecha: servicioDto.fecha, creadoPor, lat: lat ?? null, lng: lng ?? null, estado: EstadoServicio.Programado, }); const result = await this.servicioRepository.save(entity); serviceResult.boolean = true; serviceResult.message = 'Servicio creado en estado Programado.'; serviceResult.number = 1; serviceResult.object = result; return serviceResult; } async findOne(idServicio: string, user: AuthUser): Promise { const serviceResult = defaultServiceResult(); const result = await this.servicioRepository.findOneBy({ idServicio }); if (!result || result.estado === EstadoServicio.Eliminado) { serviceResult.message = 'No existe el servicio.'; return serviceResult; } const visible = await this.puedeVerServicio(user, result); if (!visible) { serviceResult.message = 'No tiene permiso para ver este servicio.'; return serviceResult; } const turnos = await this.servicioTurnoRepository.findBy({ idServicio }); const equipos = await this.servicioEquipoRepository.findBy({ idServicio }); serviceResult.boolean = true; serviceResult.message = 'Existe un servicio.'; serviceResult.number = 1; serviceResult.object = { ...result, turnos, equipos }; return serviceResult; } async find( whereConditions: WhereCondition[], orderByAttribute: string, orderByDirection: 'ASC' | 'DESC', limit: number, offset: number, user: AuthUser, ): Promise { const serviceResult = defaultServiceResult(); try { let query = this.servicioRepository.createQueryBuilder('servicio'); let index = 0; for (const condition of whereConditions) { const { attribute, value, operator = '=' } = condition; const paramKey = `param${index}`; if (attribute === 'idEquipo') { // Filtro virtual: servicio ↔ equipo es N:N vía servicio_equipo, // así que se resuelve como IN de ids. Solo aplica a where (queda // fuera de SERVICIO_FIND_WHITELIST, que sigue protegiendo orderBy. if (typeof value !== 'string') { throw new Error('Atributo idEquipo inválido.'); } const filas = await this.servicioEquipoRepository.findBy({ idEquipo: value, }); const ids = filas.map((f) => f.idServicio); if (ids.length === 0) { query = query.andWhere('1 = 0'); } else { query = query.andWhere( `servicio."idServicio" IN (:...${paramKey})`, { [paramKey]: ids }, ); } index++; continue; } if (!SERVICIO_FIND_WHITELIST.includes(attribute)) { throw new Error(`Atributo no permitido: ${attribute}`); } // `in`: value es una lista CSV (`'Publicado,EnCurso,…'`) resuelta // como IN con parámetros (tanda 2026-10-22 — Próximos servicios). if (operator === 'in') { const valores = String(value) .split(',') .map((v) => v.trim()) .filter((v) => v.length > 0); if (!valores.length) { throw new Error('Valor de in inválido.'); } const whereMethod = index === 0 ? 'where' : 'andWhere'; query = query[whereMethod]( `servicio.${attribute} IN (:...${paramKey})`, { [paramKey]: valores }, ); index++; continue; } const param = { [paramKey]: operator === 'like' ? `%${value}%` : value, }; const whereMethod = index === 0 ? 'where' : 'andWhere'; query = query[whereMethod]( `servicio.${attribute} ${operator} :${paramKey}`, param, ); index++; } // Borrado lógico: los servicios Eliminado no salen en ningún find // (ni con filtro explícito estado=Eliminado: queda 0 filas). query = query.andWhere('servicio.estado != :estadoEliminado', { estadoEliminado: EstadoServicio.Eliminado, }); await this.aplicarScoping(query, user); if (!SERVICIO_FIND_WHITELIST.includes(orderByAttribute)) { throw new Error(`Atributo de orden no permitido: ${orderByAttribute}`); } query = query.orderBy(`servicio.${orderByAttribute}`, orderByDirection); const totalRegistros = await query.getCount(); const skip = (offset - 1) * limit; query = query.skip(skip).take(limit); const result = await query.getMany(); const count = result.length; serviceResult.boolean = count > 0; serviceResult.message = `${count} servicio(s) encontrado(s).`; serviceResult.number = totalRegistros; serviceResult.data = await this.enriquecer(result); } catch (error) { serviceResult.boolean = false; serviceResult.message = `Error en el servicio: ${error.message}`; } return serviceResult; } /** * Adjunta a cada fila del find sus turnos (con `nombre` y `horaInicio` * del catálogo) y equipos (con nombre) en 4 queries por página: dos `IN` * de filas de unión y dos `IN` de catálogo. Así el card de la lista * pinta grupos, turnos y la hora de ingreso sin N+1. */ private async enriquecer(servicios: Servicio[]): Promise { if (!servicios.length) return servicios; const ids = servicios.map((s) => s.idServicio); const filasTurno = await this.servicioTurnoRepository.findBy({ idServicio: In(ids), }); const filasEquipo = await this.servicioEquipoRepository.findBy({ idServicio: In(ids), }); const idsTurno = [...new Set(filasTurno.map((t) => t.idTurno))]; const idsEquipo = [...new Set(filasEquipo.map((e) => e.idEquipo))]; const turnos = idsTurno.length ? await this.turnoRepository.findBy({ idTurno: In(idsTurno) }) : []; const equipos = idsEquipo.length ? await this.equipoRepository.findBy({ idEquipo: In(idsEquipo) }) : []; const nombreTurno = new Map(turnos.map((t) => [t.idTurno, t.nombre])); const horaTurno = new Map(turnos.map((t) => [t.idTurno, t.horaInicio])); const nombreEquipo = new Map( equipos.map((e) => [e.idEquipo, e.nombreEquipo]), ); return servicios.map((servicio) => ({ ...servicio, turnos: filasTurno .filter((t) => t.idServicio === servicio.idServicio) .sort((a, b) => a.sec - b.sec) .map((t) => ({ ...t, nombre: nombreTurno.get(t.idTurno) ?? '', horaInicio: horaTurno.get(t.idTurno) ?? null, })), equipos: filasEquipo .filter((e) => e.idServicio === servicio.idServicio) .map((e) => ({ ...e, nombreEquipo: nombreEquipo.get(e.idEquipo) ?? '', })), })); } /** * Solo editables en Programado (matriz G + Q5.6). */ async update( idServicio: string, dto: UpdateServicioDto, ): Promise { const serviceResult = defaultServiceResult(); const existente = await this.servicioRepository.findOneBy({ idServicio }); if (!existente) { serviceResult.message = 'No se encontró el servicio.'; return serviceResult; } if (existente.estado !== EstadoServicio.Programado) { serviceResult.message = 'Solo se puede editar un servicio en estado Programado.'; return serviceResult; } const clean: Partial = {}; if (dto.nombre !== undefined) clean.nombre = dto.nombre; if (dto.fecha !== undefined) clean.fecha = dto.fecha; if (dto.lat !== undefined) clean.lat = dto.lat; if (dto.lng !== undefined) clean.lng = dto.lng; if (Object.keys(clean).length === 0) { serviceResult.message = 'No hay campos para actualizar.'; return serviceResult; } const result = await this.servicioRepository.update(idServicio, clean); serviceResult.boolean = result.affected === 1; serviceResult.message = result.affected === 1 ? 'Servicio actualizado correctamente.' : 'No se encontró el servicio.'; serviceResult.number = result.affected || 0; return serviceResult; } /** * Máquina de estados + efectos: * - Publicado: valida mínimos y crea asistencias Titular * - Cancelado: cancela convocatorias abiertas y asistencias Pendiente */ async cambiarEstado( idServicio: string, dto: CambiarEstadoServicioDto, user: AuthUser, ): Promise { const serviceResult = defaultServiceResult(); const servicio = await this.servicioRepository.findOneBy({ idServicio }); if (!servicio) { serviceResult.message = 'No se encontró el servicio.'; return serviceResult; } const destino = dto.estado; const esGlobal = isSuperAdmin(user) || isDeveloper(user); // SuperAdmin/Developer pueden corregir cualquier salto de estado (matriz // relajada para "se equivocó de servicio"): cualquier destino salvo el // actual, con los mismos efectos de publicar/cancelar/finalizar. // `Eliminado` queda fuera: solo se llega vía DELETE /servicios/:id, que // tiene sus propias reglas (solo Programado/Publicado). const permitidos: string[] = esGlobal ? Object.values(EstadoServicio).filter( (e) => e !== servicio.estado && e !== EstadoServicio.Eliminado, ) : (SERVICIO_TRANSICIONES[servicio.estado] ?? []); if (!permitidos.includes(destino)) { serviceResult.message = `Transición inválida: ${servicio.estado} → ${destino}.`; return serviceResult; } // Fuera de SuperAdmin/Dev solo el Líder puede finalizar, y solo si es // miembro activo de al menos un equipo convocado del servicio (cada // líder cierra únicamente de su equipo; tanda 2026-10-17). let equiposPropios: string[] = []; if (!esGlobal) { if (user.rol !== Rol.Lider || destino !== EstadoServicio.Finalizado) { serviceResult.message = 'Solo el Líder del equipo puede finalizar el servicio (o un SuperAdmin).'; return serviceResult; } const convocados = await this.servicioEquipoRepository.findBy({ idServicio, }); const membresias = await this.equipoPersonaRepository.findBy({ idPersona: user.idPersona, estado: EstadoMiembro.Activo, }); const propios = new Set(membresias.map((m) => m.idEquipo)); equiposPropios = convocados .map((c) => c.idEquipo) .filter((id) => propios.has(id)); if (!equiposPropios.length) { serviceResult.message = 'Solo el líder de un equipo convocado del servicio puede finalizarlo.'; return serviceResult; } } if (destino === EstadoServicio.Publicado) { const ok = await this.publicar(servicio); if (!ok.ok) { serviceResult.message = ok.message; return serviceResult; } serviceResult.boolean = true; serviceResult.message = ok.message; serviceResult.number = 1; const actualizado = await this.servicioRepository.findOneBy({ idServicio, }); serviceResult.object = actualizado; if (this.eventsService && actualizado) { try { const filas = await this.asistenciaRepository.findBy({ idServicio }); const ids = [...new Set(filas.map((f) => f.idPersona))]; if (ids.length) { await this.eventsService.emitToPersonas({ event: 'servicio:publicado', title: 'Servicio publicado', body: `El servicio "${actualizado.nombre}" ya está publicado.`, idPersonas: ids, data: { idServicio }, }); } } catch (error) { this.logger.warn( `No se pudo emitir servicio:publicado: ${error.message}`, ); } } return serviceResult; } if (destino === EstadoServicio.Cancelado) { await this.cancelarEfectos(idServicio); await this.servicioRepository.update(idServicio, { estado: EstadoServicio.Cancelado, }); serviceResult.boolean = true; serviceResult.message = 'Servicio cancelado. Convocatorias abiertas canceladas y asistencias Pendiente a Eliminado.'; serviceResult.number = 1; return serviceResult; } await this.servicioRepository.update(idServicio, { estado: destino }); let mensaje = `Servicio actualizado a '${destino}'.`; if (destino === EstadoServicio.Finalizado) { // Método de salida (tanda 2026-10-22): la autorización manda. // Líder del equipo convocado → 'Líder'; SuperAdmin/Dev → 'Sistema'. // marcadoSalidaPor siempre registra quién autorizó el cierre. const metodoSalida = esGlobal ? MetodoMarcado.Sistema : MetodoMarcado.Lider; // Cierre de salidas: solo de quienes ingresaron y aún no salen. // Líder → solo sus equipos convocados; SuperAdmin/Dev → todos. let qb = this.asistenciaRepository .createQueryBuilder() .update(Asistencia) .set({ fecSalida: () => 'now()', metodoSalida, marcadoSalidaPor: user.idPersona, }) .where('"idServicio" = :idServicio', { idServicio }) .andWhere('"fecIngreso" IS NOT NULL') .andWhere('"fecSalida" IS NULL'); if (!esGlobal) { qb = qb.andWhere('"idEquipo" IN (:...idsEquipos)', { idsEquipos: equiposPropios, }); } const cerradas = await qb.execute(); const n = cerradas.affected ?? 0; // Re-evaluación de estado al finalizar (tanda 2026-10-22), en este // orden de prioridad: // 1) persona no Activa → Eliminado (aunque haya marcado o Permiso). // 2) Permiso (manual) → se respeta, no se toca. // 3) sin ingreso → Falta, sin observación automática (la observación // es solo para justificar Permiso/Falta manuales). // 4) con ingreso → Presente/Atrasado según fecIngreso vs inicio del // turno más temprano, sin tolerancia (igual que marcar()). // Un Eliminado existente no se re-abre. const umbral = await this.umbralInicio(servicio); const params: unknown[] = [idServicio]; let alcance = ''; if (!esGlobal) { params.push(equiposPropios); alcance = 'AND a."idEquipo" = ANY($2::uuid[])'; } params.push(umbral); const iUmbral = params.length; const resp = (await this.asistenciaRepository.query( `UPDATE asistencia a SET estado = CASE WHEN p.estado <> 'Activo' THEN 'Eliminado' WHEN a.estado = 'Permiso' THEN 'Permiso' WHEN a."fecIngreso" IS NULL THEN 'Falta' WHEN $${iUmbral}::timestamptz IS NOT NULL AND a."fecIngreso" > $${iUmbral}::timestamptz THEN 'Atrasado' ELSE 'Presente' END FROM persona p WHERE p."idPersona" = a."idPersona" AND a."idServicio" = $1 AND a.estado <> 'Eliminado' ${alcance}`, params, )) as unknown; // pg entrega [rows, rowCount] para UPDATE (QueryRunner sin structured). const m = Array.isArray(resp) && typeof resp[1] === 'number' ? resp[1] : 0; const detalle = n > 0 && m > 0 ? `Se cerró la salida de ${n} integrante(s) y se re-evaluó ${m} estado(s)` : n > 0 ? `Se cerró la salida de ${n} integrante(s)` : m > 0 ? `Se re-evaluó ${m} estado(s)` : ''; mensaje = !detalle ? 'Servicio finalizado.' : esGlobal ? `Servicio finalizado. ${detalle}.` : `Servicio finalizado. ${detalle} de tu equipo.`; } serviceResult.boolean = true; serviceResult.message = mensaje; serviceResult.number = 1; return serviceResult; } /** * Inicio del turno más temprano (primer turno por `sec`) del servicio como * fecha-hora; `null` si no hay fecha o turno con hora parseable. Es el mismo * umbral que usa `estadoMarcado()` al marcar ingreso (sin tolerancia). */ private async umbralInicio(servicio: Servicio): Promise { if (!servicio.fecha) return null; const st = await this.servicioTurnoRepository.findOne({ where: { idServicio: servicio.idServicio }, order: { sec: 'ASC' }, }); if (!st) return null; const turno = await this.turnoRepository.findOneBy({ idTurno: st.idTurno }); if (!turno?.horaInicio) return null; const hora = turno.horaInicio.length === 5 ? `${turno.horaInicio}:00` : turno.horaInicio; const inicio = new Date(`${servicio.fecha}T${hora}`); return Number.isNaN(inicio.getTime()) ? null : inicio; } /** * DELETE = borrado lógico (`estado = Eliminado`) de **cualquier estado** * (decisión del usuario 2026-10-10: antes solo borradores). Aplica los * mismos efectos que Cancelar (convocatorias/apoyos abiertos y asistencias * Pendiente). Solo un servicio ya `Eliminado` se rechaza. */ async remove(idServicio: string): Promise { const serviceResult = defaultServiceResult(); const existente = await this.servicioRepository.findOneBy({ idServicio }); if (!existente) { serviceResult.message = 'No se encontró el servicio.'; return serviceResult; } if (existente.estado === EstadoServicio.Eliminado) { serviceResult.message = 'El servicio ya está eliminado.'; return serviceResult; } await this.cancelarEfectos(idServicio); await this.servicioRepository.update(idServicio, { estado: EstadoServicio.Eliminado, }); serviceResult.boolean = true; serviceResult.message = 'Servicio eliminado.'; serviceResult.number = 1; return serviceResult; } private async publicar( servicio: Servicio, ): Promise<{ ok: boolean; message: string }> { const turnos = await this.servicioTurnoRepository.findBy({ idServicio: servicio.idServicio, }); const equipos = await this.servicioEquipoRepository.findBy({ idServicio: servicio.idServicio, }); if (!turnos.length) { return { ok: false, message: 'No se puede publicar sin al menos un turno.', }; } // 0 equipos permitido: servicio extraordinario solo con turnos + apoyos (regla N1) // lat/lng heredados si faltan if (servicio.lat == null || servicio.lng == null) { const config = await this.configuracionRepository.findOneBy({}); if (config) { await this.servicioRepository.update(servicio.idServicio, { lat: servicio.lat ?? config.lat, lng: servicio.lng ?? config.lng, }); } } const miembrosActivos: { idPersona: string; idEquipo: string }[] = []; for (const se of equipos) { const filas = await this.equipoPersonaRepository.findBy({ idEquipo: se.idEquipo, estado: EstadoMiembro.Activo, }); for (const f of filas) { miembrosActivos.push({ idPersona: f.idPersona, idEquipo: f.idEquipo }); } } if (!miembrosActivos.length) { return { ok: false, message: 'Los equipos convocados no tienen miembros activos.', }; } await this.servicioRepository.manager.transaction(async (manager) => { // solo insertar si no existen ya (idempotente) for (const m of miembrosActivos) { const existe = await manager.findOne(Asistencia, { where: { idServicio: servicio.idServicio, idPersona: m.idPersona }, }); if (existe) continue; await manager.insert(Asistencia, { idServicio: servicio.idServicio, idEquipo: m.idEquipo, idPersona: m.idPersona, tipo: TipoAsistencia.Titular, estado: EstadoAsistencia.Pendiente, }); } await manager.update(Servicio, servicio.idServicio, { estado: EstadoServicio.Publicado, // (Re)genera el PIN de marcado en cada publicación. pinMarcado: this.generarPin(), }); }); return { ok: true, message: equipos.length === 0 ? `Servicio publicado sin equipos (extraordinario). ${turnos.length} turno(s) configurado(s).` : `Servicio publicado. ${miembrosActivos.length} asistencia(s) titular(es) en estado Pendiente.`, }; } private async cancelarEfectos(idServicio: string): Promise { await this.reemplazoRepository .createQueryBuilder() .update(Reemplazo) .set({ estado: EstadoConvocatoria.Cancelado }) .where('"idServicio" = :idServicio', { idServicio }) .andWhere('estado = :estado', { estado: EstadoConvocatoria.Abierto }) .execute(); await this.solicitudApoyoRepository .createQueryBuilder() .update(SolicitudApoyo) .set({ estado: EstadoConvocatoria.Cancelado }) .where('"idServicio" = :idServicio', { idServicio }) .andWhere('estado = :estado', { estado: EstadoConvocatoria.Abierto }) .execute(); await this.asistenciaRepository .createQueryBuilder() .update(Asistencia) .set({ estado: EstadoAsistencia.Eliminado }) .where('"idServicio" = :idServicio', { idServicio }) .andWhere('estado = :estado', { estado: EstadoAsistencia.Pendiente }) .execute(); } private async aplicarScoping(query: any, user: AuthUser): Promise { if (isDeveloper(user) || isSuperAdmin(user) || user.rol === Rol.Admin) { return; } if (user.rol === Rol.Lider || user.rol === Rol.Estaca) { const misEquipos = await this.equipoPersonaRepository .createQueryBuilder('ep') .select('ep."idEquipo"') .where('ep."idPersona" = :id', { id: user.idPersona }) .andWhere('ep.estado = :e', { e: EstadoMiembro.Activo }) .getRawMany(); const ids = misEquipos.map((r: { idEquipo: string }) => r.idEquipo); if (!ids.length) { query.andWhere('1 = 0'); return; } const sub = this.servicioEquipoRepository .createQueryBuilder('se') .select('se."idServicio"') .where('se."idEquipo" IN (:...ids)', { ids }) .andWhere( `(servicio.estado IN ('Publicado','EnCurso','Finalizado') OR servicio."creadoPor" = :idUser)`, { idUser: user.idPersona }, ); // más simple: ve servicios de sus equipos en estados visibles o creados por él query.andWhere( `servicio."idServicio" IN ( SELECT se."idServicio" FROM servicio_equipo se WHERE se."idEquipo" IN (${ids.map((_, i) => `:eq${i}`).join(',')}) ) OR servicio."creadoPor" = :idUser`, { ...Object.fromEntries(ids.map((id, i) => [`eq${i}`, id])), idUser: user.idPersona, }, ); // filtrar Programado si no es SuperAdmin: Líder no ve borradores ajenos query.andWhere( `(servicio.estado != 'Programado' OR servicio."creadoPor" = :idUser)`, { idUser: user.idPersona }, ); return; } // Servidor / Usuario: servicios publicados/en curso/finalizados o donde participa const subAsist = this.asistenciaRepository .createQueryBuilder('a') .select('a."idServicio"') .where('a."idPersona" = :id', { id: user.idPersona }); query.andWhere( `(servicio.estado IN ('Publicado','EnCurso','Finalizado') OR servicio."idServicio" IN (${subAsist.getQuery()}))`, { id: user.idPersona }, ); query.setParameters(subAsist.getParameters()); } private async puedeVerServicio( user: AuthUser, servicio: Servicio, ): Promise { if (isDeveloper(user) || isSuperAdmin(user) || user.rol === Rol.Admin) return true; if (servicio.creadoPor === user.idPersona) return true; if (servicio.estado === EstadoServicio.Programado) return false; if (user.rol === Rol.Lider || user.rol === Rol.Estaca) { const equipos = await this.servicioEquipoRepository.findBy({ idServicio: servicio.idServicio, }); for (const e of equipos) { const m = await this.equipoPersonaRepository.findOneBy({ idPersona: user.idPersona, idEquipo: e.idEquipo, estado: EstadoMiembro.Activo, }); if (m) return true; } return false; } const a = await this.asistenciaRepository.findOneBy({ idServicio: servicio.idServicio, idPersona: user.idPersona, }); return !!a; } /** Regenera el PIN de marcado de un servicio publicado o en curso (SuperAdmin). */ async regenerarPin(idServicio: string): Promise { const serviceResult = defaultServiceResult(); const servicio = await this.servicioRepository.findOneBy({ idServicio }); if (!servicio) { serviceResult.message = 'No se encontró el servicio.'; return serviceResult; } if (servicio.estado === EstadoServicio.Eliminado) { serviceResult.message = 'El servicio está eliminado.'; return serviceResult; } if ( servicio.estado !== EstadoServicio.Publicado && servicio.estado !== EstadoServicio.EnCurso ) { serviceResult.message = 'Solo se regenera el PIN de servicios publicados o en curso.'; return serviceResult; } const pin = this.generarPin(); await this.servicioRepository.update(idServicio, { pinMarcado: pin }); serviceResult.boolean = true; serviceResult.message = 'PIN regenerado correctamente.'; serviceResult.number = 1; serviceResult.object = { idServicio, pinMarcado: pin }; return serviceResult; } /** PIN de 6 dígitos para marcar (tecleado o escaneado en QR). */ private generarPin(): string { return Math.floor(Math.random() * 1_000_000) .toString() .padStart(6, '0'); } }