364 lines
12 KiB
TypeScript
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;
|
|
}
|
|
}
|