app-min-ser-nest/src/modules/solicitud-apoyo/solicitud-apoyo.service.ts
2026-10-17 19:40:29 -04:00

364 lines
12 KiB
TypeScript

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { SolicitudApoyo } from './entities/solicitud-apoyo.entity.js';
import { Servicio } from '../servicio/entities/servicio.entity.js';
import { Asistencia } from '../asistencia/entities/asistencia.entity.js';
import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js';
import { Persona } from '../persona/entities/persona.entity.js';
import { SolicitudApoyoDto, UpdateSolicitudApoyoDto } from './dto/solicitud-apoyo.dto.js';
import { defaultServiceResult, ServiceResult } from '../../common/interfaces/service.result.js';
import { WhereCondition } from '../../common/types/query-builder.types.js';
import {
EstadoAsistencia,
EstadoConvocatoria,
EstadoGeneral,
EstadoMiembro,
EstadoServicio,
} from '../../common/enums/estados.enum.js';
import { TipoAsistencia } from '../../common/enums/tipos.enum.js';
import { Rol } from '../../common/enums/rol.enum.js';
import { SOLICITUD_APOYO_FIND_WHITELIST } from './solicitud-apoyo.constants.js';
import { AuthUser, isDeveloper, isSuperAdmin } from '../../common/utils/auth-user.js';
@Injectable()
export class SolicitudApoyoService {
constructor(
@InjectRepository(SolicitudApoyo)
private solicitudApoyoRepository: Repository<SolicitudApoyo>,
@InjectRepository(Servicio)
private servicioRepository: Repository<Servicio>,
@InjectRepository(Asistencia)
private asistenciaRepository: Repository<Asistencia>,
@InjectRepository(EquipoPersona)
private equipoPersonaRepository: Repository<EquipoPersona>,
@InjectRepository(Persona)
private personaRepository: Repository<Persona>,
) {}
async create(dto: SolicitudApoyoDto, user: AuthUser): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const solicitadoPor = user.idPersona;
const servicio = await this.servicioRepository.findOneBy({
idServicio: dto.idServicio,
});
if (!servicio) {
serviceResult.message = 'No existe el servicio.';
return serviceResult;
}
if (servicio.estado !== EstadoServicio.Publicado) {
serviceResult.message = 'Solo se puede solicitar apoyo en servicio Publicado.';
return serviceResult;
}
if (!isDeveloper(user)) {
if (user.rol !== Rol.Lider) {
serviceResult.message = 'Solo el Líder del equipo (o Developer) puede pedir apoyo.';
return serviceResult;
}
const esLider = await this.equipoPersonaRepository.findOneBy({
idPersona: solicitadoPor,
idEquipo: dto.idEquipo,
estado: EstadoMiembro.Activo,
});
if (!esLider) {
serviceResult.message = 'Solo el Líder de ese equipo puede solicitar apoyo.';
return serviceResult;
}
}
const entity = this.solicitudApoyoRepository.create({
idServicio: dto.idServicio,
idEquipo: dto.idEquipo,
solicitadoPor,
cuposSolicitados: dto.cuposSolicitados,
cuposCubiertos: 0,
motivo: dto.motivo ?? null,
estado: EstadoConvocatoria.Abierto,
});
const result = await this.solicitudApoyoRepository.save(entity);
serviceResult.boolean = true;
serviceResult.message = 'Convocatoria de apoyo abierta.';
serviceResult.number = 1;
serviceResult.object = result;
return serviceResult;
}
async findOne(idSolicitudApoyo: string, user: AuthUser): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const result = await this.solicitudApoyoRepository.findOneBy({ idSolicitudApoyo });
if (!result) {
serviceResult.message = 'No existe la solicitud de apoyo.';
return serviceResult;
}
const ok = await this.puedeVer(user, result);
if (!ok) {
serviceResult.message = 'No tiene permiso para ver esta solicitud.';
return serviceResult;
}
serviceResult.boolean = true;
serviceResult.message = 'Existe una solicitud de apoyo.';
serviceResult.number = 1;
serviceResult.object = result;
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.solicitudApoyoRepository.createQueryBuilder('solicitud_apoyo');
whereConditions.forEach((condition, index) => {
const { attribute, value, operator = '=' } = condition;
if (!SOLICITUD_APOYO_FIND_WHITELIST.includes(attribute)) {
throw new Error(`Atributo no permitido: ${attribute}`);
}
const paramKey = `param${index}`;
const param = {
[paramKey]: operator === 'like' ? `%${value}%` : value,
};
const whereMethod = index === 0 ? 'where' : 'andWhere';
query = query[whereMethod](
`solicitud_apoyo.${attribute} ${operator} :${paramKey}`,
param,
);
});
// Usuarios normales ven Abiertas elegibles + las suyas
if (user.rol === Rol.Servidor || user.rol === Rol.Estaca) {
query = query.andWhere(
`(solicitud_apoyo.estado = 'Abierto' OR solicitud_apoyo.solicitadoPor = :id)`,
{ id: user.idPersona },
);
}
if (!SOLICITUD_APOYO_FIND_WHITELIST.includes(orderByAttribute)) {
throw new Error(`Atributo de orden no permitido: ${orderByAttribute}`);
}
query = query.orderBy(`solicitud_apoyo.${orderByAttribute}`, orderByDirection);
const totalRegistros = await query.getCount();
const skip = (offset - 1) * limit;
query = query.skip(skip).take(limit);
const result = await query.getMany();
serviceResult.boolean = result.length > 0;
serviceResult.message = `${result.length} solicitud(es) de apoyo encontrada(s).`;
serviceResult.number = totalRegistros;
serviceResult.data = result;
} catch (error) {
serviceResult.boolean = false;
serviceResult.message = `Error en el servicio: ${error.message}`;
}
return serviceResult;
}
async update(
idSolicitudApoyo: string,
dto: UpdateSolicitudApoyoDto,
): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const existente = await this.solicitudApoyoRepository.findOneBy({ idSolicitudApoyo });
if (!existente) {
serviceResult.message = 'No se encontró la solicitud de apoyo.';
return serviceResult;
}
if (existente.estado !== EstadoConvocatoria.Abierto) {
serviceResult.message = 'Solo se pueden editar solicitudes Abiertas.';
return serviceResult;
}
const clean: Partial<SolicitudApoyo> = {};
if (dto.cuposSolicitados !== undefined) clean.cuposSolicitados = dto.cuposSolicitados;
if (dto.motivo !== undefined) clean.motivo = dto.motivo;
if (Object.keys(clean).length === 0) {
serviceResult.message = 'No hay campos para actualizar.';
return serviceResult;
}
const result = await this.solicitudApoyoRepository.update(idSolicitudApoyo, clean);
serviceResult.boolean = result.affected === 1;
serviceResult.message = 'Solicitud de apoyo actualizada.';
serviceResult.number = result.affected || 0;
return serviceResult;
}
/**
* Aceptar apoyo: elegibilidad + cupo atómico + fila Asistencia Apoyo.
*/
async aceptar(idSolicitudApoyo: string, user: AuthUser): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const solicitud = await this.solicitudApoyoRepository.findOneBy({ idSolicitudApoyo });
if (!solicitud) {
serviceResult.message = 'No existe la solicitud de apoyo.';
return serviceResult;
}
if (solicitud.estado !== EstadoConvocatoria.Abierto) {
serviceResult.message = 'La convocatoria no está Abierta.';
return serviceResult;
}
if (solicitud.cuposCubiertos >= solicitud.cuposSolicitados) {
serviceResult.message = 'Cupos agotados.';
return serviceResult;
}
const solicitante = user.idPersona;
const persona = await this.personaRepository.findOneBy({ idPersona: solicitante });
if (!persona || persona.estado !== EstadoGeneral.Activo) {
serviceResult.message = 'La persona no existe o no está activa.';
return serviceResult;
}
if (persona.rol === Rol.Admin) {
serviceResult.message = 'El rol Admin no puede ser apoyo.';
return serviceResult;
}
// no puede ser del equipo que pidió apoyo
const esDelEquipoSolicitante = await this.equipoPersonaRepository.findOneBy({
idPersona: solicitante,
idEquipo: solicitud.idEquipo,
estado: EstadoMiembro.Activo,
});
if (esDelEquipoSolicitante) {
serviceResult.message = 'No puede apoyar: pertenece al equipo que solicitó.';
return serviceResult;
}
// no puede estar en equipos asignados al servicio
const equiposServicio = await this.asistenciaRepository.query(
`SELECT DISTINCT "idEquipo" FROM servicio_equipo WHERE "idServicio" = $1`,
[solicitud.idServicio],
);
for (const row of equiposServicio as { idEquipo: string }[]) {
const m = await this.equipoPersonaRepository.findOneBy({
idPersona: solicitante,
idEquipo: row.idEquipo,
estado: EstadoMiembro.Activo,
});
if (m) {
serviceResult.message =
'No puede apoyar: pertenece a un equipo asignado a ese servicio.';
return serviceResult;
}
}
const yaAsistio = await this.asistenciaRepository.findOneBy({
idServicio: solicitud.idServicio,
idPersona: solicitante,
});
if (yaAsistio) {
serviceResult.message = 'Ya tiene una fila de asistencia en este servicio.';
return serviceResult;
}
const membresia = await this.equipoPersonaRepository.findOneBy({
idPersona: solicitante,
estado: EstadoMiembro.Activo,
});
const resultado = await this.solicitudApoyoRepository.manager.transaction(
async (manager) => {
const upd = await manager
.createQueryBuilder()
.update(SolicitudApoyo)
.set({
cuposCubiertos: () => '"cuposCubiertos" + 1',
estado: () =>
`CASE WHEN "cuposCubiertos" + 1 >= "cuposSolicitados" THEN 'Cubierto' ELSE estado END`,
})
.where('"idSolicitudApoyo" = :id', { id: idSolicitudApoyo })
.andWhere("estado = 'Abierto'")
.andWhere('"cuposCubiertos" < "cuposSolicitados"')
.execute();
if (upd.affected === 0) {
return { ok: false, message: 'Cupos agotados o convocatoria no válida.' };
}
await manager.insert(Asistencia, {
idServicio: solicitud.idServicio,
idEquipo: membresia?.idEquipo ?? solicitud.idEquipo,
idPersona: solicitante,
tipo: TipoAsistencia.Apoyo,
idSolicitudApoyo,
estado: EstadoAsistencia.Pendiente,
});
return { ok: true, message: 'Te has unido como apoyo.' };
},
);
serviceResult.boolean = resultado.ok;
serviceResult.message = resultado.message;
serviceResult.number = resultado.ok ? 1 : 0;
return serviceResult;
}
async cancelar(idSolicitudApoyo: string, user: AuthUser): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const puedeAdmin = isDeveloper(user) || isSuperAdmin(user);
if (!puedeAdmin) {
serviceResult.message = 'Solo SuperAdmin/Developer pueden cancelar convocatorias.';
return serviceResult;
}
const result = await this.solicitudApoyoRepository.update(
{ idSolicitudApoyo, estado: EstadoConvocatoria.Abierto },
{ estado: EstadoConvocatoria.Cancelado },
);
serviceResult.boolean = result.affected === 1;
serviceResult.message =
result.affected === 1
? 'Solicitud de apoyo cancelada.'
: 'No se pudo cancelar (solo Abiertas).';
serviceResult.number = result.affected || 0;
return serviceResult;
}
private async puedeVer(user: AuthUser, s: SolicitudApoyo): Promise<boolean> {
if (isDeveloper(user) || isSuperAdmin(user) || user.rol === Rol.Admin) return true;
if (s.solicitadoPor === user.idPersona) return true;
if (user.rol === Rol.Lider || user.rol === Rol.Estaca) {
const m = await this.equipoPersonaRepository.findOneBy({
idPersona: user.idPersona,
idEquipo: s.idEquipo,
estado: EstadoMiembro.Activo,
});
return !!m || s.estado === EstadoConvocatoria.Abierto;
}
return s.estado === EstadoConvocatoria.Abierto;
}
}