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

832 lines
29 KiB
TypeScript

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<Servicio>,
@InjectRepository(ServicioTurno)
private servicioTurnoRepository: Repository<ServicioTurno>,
@InjectRepository(ServicioEquipo)
private servicioEquipoRepository: Repository<ServicioEquipo>,
@InjectRepository(EquipoPersona)
private equipoPersonaRepository: Repository<EquipoPersona>,
@InjectRepository(Turno)
private turnoRepository: Repository<Turno>,
@InjectRepository(Equipo)
private equipoRepository: Repository<Equipo>,
@InjectRepository(Asistencia)
private asistenciaRepository: Repository<Asistencia>,
@InjectRepository(Configuracion)
private configuracionRepository: Repository<Configuracion>,
@InjectRepository(Reemplazo)
private reemplazoRepository: Repository<Reemplazo>,
@InjectRepository(SolicitudApoyo)
private solicitudApoyoRepository: Repository<SolicitudApoyo>,
@Optional() private readonly eventsService?: EventsService,
) {}
async create(
servicioDto: ServicioDto,
user: AuthUser,
): Promise<ServiceResult> {
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<ServiceResult> {
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<ServiceResult> {
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<Servicio[]> {
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<ServiceResult> {
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<Servicio> = {};
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<ServiceResult> {
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<Date | null> {
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<ServiceResult> {
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<void> {
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<void> {
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<boolean> {
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<ServiceResult> {
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');
}
}