832 lines
29 KiB
TypeScript
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');
|
|
}
|
|
}
|