9no Commit
This commit is contained in:
parent
ea60405fa1
commit
78924159bf
33 changed files with 2570 additions and 490 deletions
|
|
@ -8,6 +8,8 @@ services:
|
|||
- "4002:4002"
|
||||
env_file:
|
||||
- .env
|
||||
environment:
|
||||
TZ: America/La_Paz
|
||||
restart: unless-stopped
|
||||
networks:
|
||||
- red_postgres
|
||||
|
|
|
|||
26
src/common/utils/zona-horaria.ts
Normal file
26
src/common/utils/zona-horaria.ts
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
/**
|
||||
* Zona horaria de la organización para los cálculos de hora "de pared"
|
||||
* (Atrasado/Presente). Formato `±HH:MM` (p. ej. `-04:00` = Bolivia).
|
||||
*
|
||||
* El servidor puede correr en UTC: `new Date('…T07:00')` se interpretaría
|
||||
* en la zona del contenedor y dispararía el umbral 4 horas antes. Con el
|
||||
* offset explícito de `configuracion.zonaHoraria` el cálculo no depende de
|
||||
* dónde esté desplegado el backend.
|
||||
*/
|
||||
export const ZONA_HORA_RE = /^[+-](0\d|1[0-4]):[0-5]\d$/;
|
||||
|
||||
export const ZONA_HORA_DEFAULT = '-04:00';
|
||||
|
||||
/**
|
||||
* `fecha` (YYYY-MM-DD) + `hora` (HH:mm o HH:mm:ss) en la zona dada →
|
||||
* instante `Date`. Si la zona no tiene el formato `±HH:MM` se usa la
|
||||
* default.
|
||||
*/
|
||||
export function fechaHoraEnZona(
|
||||
fecha: string,
|
||||
hora: string,
|
||||
zona: string,
|
||||
): Date {
|
||||
const z = ZONA_HORA_RE.test(zona) ? zona : ZONA_HORA_DEFAULT;
|
||||
return new Date(`${fecha}T${hora}${z}`);
|
||||
}
|
||||
|
|
@ -160,9 +160,11 @@ export class AsistenciaController {
|
|||
return apiResult;
|
||||
}
|
||||
|
||||
// modificacion.txt e.i: Líder/Estaca (cualquier autorización) y Servidor
|
||||
// con Dev/SuperAdmin. Developer bypasea el guard; el service revalida
|
||||
// por fila (Dev/SuperAdmin o Líder/Estaca con membresía).
|
||||
@Patch(':idAsistencia')
|
||||
@Roles(Rol.Lider)
|
||||
@Autorizacion(AutorizacionEnum.SuperAdmin)
|
||||
@Roles(Rol.Lider, Rol.Estaca, Rol.Servidor)
|
||||
async update(
|
||||
@Req() req: AuthRequest,
|
||||
@Param('idAsistencia') idAsistencia: string,
|
||||
|
|
@ -244,8 +246,10 @@ export class AsistenciaController {
|
|||
return apiResult;
|
||||
}
|
||||
|
||||
// modificacion.txt e.i: Permiso/Falta para Líder o Estaca del equipo
|
||||
// (Developer bypasea; el service valida la membresía de la fila).
|
||||
@Post(':idAsistencia/estado')
|
||||
@Roles(Rol.Lider)
|
||||
@Roles(Rol.Lider, Rol.Estaca)
|
||||
async setEstado(
|
||||
@Req() req: AuthRequest,
|
||||
@Param('idAsistencia') idAsistencia: string,
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
import { Injectable } from '@nestjs/common';
|
||||
import { InjectRepository } from '@nestjs/typeorm';
|
||||
import { In, Repository } from 'typeorm';
|
||||
import { Repository } from 'typeorm';
|
||||
import { Asistencia } from './entities/asistencia.entity.js';
|
||||
import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js';
|
||||
import { Reemplazo } from '../reemplazo/entities/reemplazo.entity.js';
|
||||
|
|
@ -31,6 +31,10 @@ import {
|
|||
TipoAsistencia,
|
||||
} from '../../common/enums/tipos.enum.js';
|
||||
import { Rol } from '../../common/enums/rol.enum.js';
|
||||
import {
|
||||
ZONA_HORA_DEFAULT,
|
||||
fechaHoraEnZona,
|
||||
} from '../../common/utils/zona-horaria.js';
|
||||
import { ASISTENCIA_FIND_WHITELIST } from './asistencia.constants.js';
|
||||
import {
|
||||
AuthUser,
|
||||
|
|
@ -95,24 +99,26 @@ export class AsistenciaService {
|
|||
return 0;
|
||||
}
|
||||
|
||||
const servicios = await this.servicioRepository.find({
|
||||
where: {
|
||||
idServicio: In(convocatorias.map((c) => c.idServicio)),
|
||||
estado: In([EstadoServicio.Publicado, EstadoServicio.EnCurso]),
|
||||
},
|
||||
});
|
||||
const activas = convocatorias.filter(
|
||||
(c) =>
|
||||
c.estado === EstadoServicio.Publicado ||
|
||||
c.estado === EstadoServicio.EnCurso,
|
||||
);
|
||||
if (!activas.length) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
let creadas = 0;
|
||||
for (const servicio of servicios) {
|
||||
for (const c of activas) {
|
||||
const existe = await this.asistenciaRepository.findOneBy({
|
||||
idServicio: servicio.idServicio,
|
||||
idServicio: c.idServicio,
|
||||
idPersona,
|
||||
});
|
||||
if (existe) {
|
||||
continue;
|
||||
}
|
||||
await this.asistenciaRepository.insert({
|
||||
idServicio: servicio.idServicio,
|
||||
idServicio: c.idServicio,
|
||||
idEquipo,
|
||||
idPersona,
|
||||
tipo: TipoAsistencia.Titular,
|
||||
|
|
@ -179,22 +185,28 @@ export class AsistenciaService {
|
|||
);
|
||||
});
|
||||
|
||||
if (user.rol === Rol.Servidor) {
|
||||
query = query.andWhere('asistencia."idPersona" = :id', {
|
||||
id: user.idPersona,
|
||||
});
|
||||
} else 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 = query.andWhere('1 = 0');
|
||||
} else {
|
||||
query = query.andWhere('asistencia."idEquipo" IN (:...ids)', { ids });
|
||||
// Dev/SuperAdmin: sin scoping (toda la visibilidad del find; el rol
|
||||
// del usuario puede ser Líder/Estaca y no debe acotar — matriz K).
|
||||
if (!isDeveloper(user) && !isSuperAdmin(user)) {
|
||||
if (user.rol === Rol.Servidor) {
|
||||
query = query.andWhere('asistencia."idPersona" = :id', {
|
||||
id: user.idPersona,
|
||||
});
|
||||
} else 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 = query.andWhere('1 = 0');
|
||||
} else {
|
||||
query = query.andWhere('asistencia."idEquipo" IN (:...ids)', {
|
||||
ids,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -246,11 +258,19 @@ export class AsistenciaService {
|
|||
return serviceResult;
|
||||
}
|
||||
|
||||
// Evitar editar campos de marcado libre; el service de marcar es el camino
|
||||
// Campos editables desde el dot-menu (modificacion.txt e.i.3): tipo,
|
||||
// estado, observación y horas de ingreso/salida (null = borrar). El
|
||||
// marcado con método/geolocalización sigue siendo el service `marcar`.
|
||||
const clean: Partial<Asistencia> = {};
|
||||
if (dto.tipo !== undefined) clean.tipo = dto.tipo;
|
||||
if (dto.observacion !== undefined) clean.observacion = dto.observacion;
|
||||
if (dto.estado !== undefined) clean.estado = dto.estado;
|
||||
if (dto.fecIngreso !== undefined) {
|
||||
clean.fecIngreso = dto.fecIngreso === null ? null : new Date(dto.fecIngreso);
|
||||
}
|
||||
if (dto.fecSalida !== undefined) {
|
||||
clean.fecSalida = dto.fecSalida === null ? null : new Date(dto.fecSalida);
|
||||
}
|
||||
|
||||
if (Object.keys(clean).length === 0) {
|
||||
serviceResult.message = 'No hay campos permitidos para actualizar.';
|
||||
|
|
@ -297,13 +317,21 @@ export class AsistenciaService {
|
|||
return serviceResult;
|
||||
}
|
||||
|
||||
// Tanda 2026-10-17: con el servicio 'Finalizado' no se admite ingreso
|
||||
// (las faltas de los que no ingresaron ya las aplica cambiarEstado al
|
||||
// finalizar). La salida del que sí ingresó sigue permitida ese día.
|
||||
if (
|
||||
dto.accion === 'ingreso' &&
|
||||
servicio.estado === EstadoServicio.Finalizado
|
||||
) {
|
||||
// El estado vivo es el del EQUIPO de esta fila de asistencia.
|
||||
const se = await this.servicioEquipoRepository.findOneBy({
|
||||
idServicio: asistencia.idServicio,
|
||||
idEquipo: asistencia.idEquipo,
|
||||
});
|
||||
const estadoEquipo = se?.estado;
|
||||
|
||||
// Con el equipo 'Finalizado' no se admite ingreso (las faltas de los
|
||||
// que no ingresaron ya las aplica el cierre). La salida del que sí
|
||||
// ingresó sigue permitida ese día. Sin fila de equipo (servicio
|
||||
// extraordinario) se usa `servicio.estado`.
|
||||
const estadoVivo = se
|
||||
? estadoEquipo
|
||||
: (servicio.estado as EstadoServicio | null);
|
||||
if (dto.accion === 'ingreso' && estadoVivo === EstadoServicio.Finalizado) {
|
||||
serviceResult.message =
|
||||
'El servicio ya está finalizado: no se puede registrar ingreso.';
|
||||
return serviceResult;
|
||||
|
|
@ -327,7 +355,9 @@ export class AsistenciaService {
|
|||
serviceResult.message = `Marcado ${dto.metodo} requiere pin.`;
|
||||
return serviceResult;
|
||||
}
|
||||
if (!servicio?.pinMarcado || servicio.pinMarcado !== pin) {
|
||||
// PIN por equipo (multi-equipo); sin fila de equipo no hay PIN.
|
||||
const pinEsperado = se?.pinMarcado;
|
||||
if (!pinEsperado || pinEsperado !== pin) {
|
||||
serviceResult.message = 'PIN incorrecto.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
|
@ -436,9 +466,10 @@ export class AsistenciaService {
|
|||
}
|
||||
|
||||
/**
|
||||
* Estado al ingresar: `Atrasado` si ya pasó la hora de inicio del turno más
|
||||
* temprano del servicio (sin tolerancia); si no, `Presente`. Sin turnos o
|
||||
* sin hora parseable, queda `Presente`.
|
||||
* Estado al ingresar: `Atrasado` si ya pasó la hora límite de la primera
|
||||
* reunión del servicio (`limiteIngreso ?? horaInicio`) más
|
||||
* `configuracion.tolerancia` minutos; si no, `Presente`. Sin turnos o sin
|
||||
* hora parseable, queda `Presente`.
|
||||
*/
|
||||
private async estadoMarcado(
|
||||
servicio?: Servicio | null,
|
||||
|
|
@ -452,16 +483,31 @@ export class AsistenciaService {
|
|||
if (!st) return EstadoAsistencia.Presente;
|
||||
|
||||
const turno = await this.turnoRepository.findOneBy({ idTurno: st.idTurno });
|
||||
if (!turno?.horaInicio) return EstadoAsistencia.Presente;
|
||||
if (!turno) return EstadoAsistencia.Presente;
|
||||
|
||||
const hora =
|
||||
turno.horaInicio.length === 5
|
||||
? `${turno.horaInicio}:00`
|
||||
: turno.horaInicio;
|
||||
const inicio = new Date(`${servicio.fecha}T${hora}`);
|
||||
if (Number.isNaN(inicio.getTime())) return EstadoAsistencia.Presente;
|
||||
// Hora de referencia: límite de ingreso o, si no, inicio de la reunión.
|
||||
const horaRef =
|
||||
(turno.limiteIngreso && turno.limiteIngreso.length >= 5
|
||||
? turno.limiteIngreso
|
||||
: turno.horaInicio) ?? null;
|
||||
if (!horaRef) return EstadoAsistencia.Presente;
|
||||
|
||||
return Date.now() > inicio.getTime()
|
||||
const hora = horaRef.length === 5 ? `${horaRef}:00` : horaRef;
|
||||
|
||||
const config = await this.configuracionRepository.findOneBy({});
|
||||
const tolerancia = config?.tolerancia ?? 0;
|
||||
// Hora de pared de la organización (config.zonaHoraria): el reloj del
|
||||
// servidor no manda para calcular Atrasado.
|
||||
const base = fechaHoraEnZona(
|
||||
String(servicio.fecha),
|
||||
hora,
|
||||
config?.zonaHoraria ?? ZONA_HORA_DEFAULT,
|
||||
);
|
||||
if (Number.isNaN(base.getTime())) return EstadoAsistencia.Presente;
|
||||
|
||||
const umbral = base.getTime() + tolerancia * 60_000;
|
||||
|
||||
return Date.now() > umbral
|
||||
? EstadoAsistencia.Atrasado
|
||||
: EstadoAsistencia.Presente;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -101,15 +101,15 @@ export class UpdateAsistenciaDto {
|
|||
@IsOptional()
|
||||
observacion?: string;
|
||||
|
||||
@ApiProperty({ required: false })
|
||||
@ApiProperty({ required: false, nullable: true })
|
||||
@IsDateString()
|
||||
@IsOptional()
|
||||
fecIngreso?: string;
|
||||
fecIngreso?: string | null;
|
||||
|
||||
@ApiProperty({ required: false })
|
||||
@ApiProperty({ required: false, nullable: true })
|
||||
@IsDateString()
|
||||
@IsOptional()
|
||||
fecSalida?: string;
|
||||
fecSalida?: string | null;
|
||||
|
||||
@ApiProperty({ enum: MetodoMarcado, required: false })
|
||||
@IsEnum(MetodoMarcado)
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ import { Configuracion } from './entities/configuracion.entity.js';
|
|||
import { ConfiguracionDto } from './dto/configuracion.dto.js';
|
||||
import { UpdateConfiguracionDto } from './dto/update-configuracion.dto.js';
|
||||
import { defaultServiceResult, ServiceResult } from '../../common/interfaces/service.result.js';
|
||||
import { ZONA_HORA_DEFAULT, ZONA_HORA_RE } from '../../common/utils/zona-horaria.js';
|
||||
|
||||
@Injectable()
|
||||
export class ConfiguracionService {
|
||||
|
|
@ -47,11 +48,28 @@ export class ConfiguracionService {
|
|||
serviceResult.message = 'La distancia debe ser mayor a 0.';
|
||||
return serviceResult;
|
||||
}
|
||||
if (
|
||||
configuracionDto.tolerancia !== undefined &&
|
||||
configuracionDto.tolerancia < 0
|
||||
) {
|
||||
serviceResult.message = 'La tolerancia no puede ser negativa.';
|
||||
return serviceResult;
|
||||
}
|
||||
if (
|
||||
configuracionDto.zonaHoraria !== undefined &&
|
||||
!ZONA_HORA_RE.test(configuracionDto.zonaHoraria)
|
||||
) {
|
||||
serviceResult.message =
|
||||
'Zona horaria inválida (use ±HH:MM, p. ej. -04:00).';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
const entity = this.configuracionRepository.create({
|
||||
lat: configuracionDto.lat,
|
||||
lng: configuracionDto.lng,
|
||||
distancia: configuracionDto.distancia,
|
||||
tolerancia: configuracionDto.tolerancia ?? 0,
|
||||
zonaHoraria: configuracionDto.zonaHoraria ?? ZONA_HORA_DEFAULT,
|
||||
openwaSessionId: configuracionDto.openwaSessionId ?? null,
|
||||
});
|
||||
const result = await this.configuracionRepository.save(entity);
|
||||
|
|
@ -81,6 +99,21 @@ export class ConfiguracionService {
|
|||
serviceResult.message = 'La distancia debe ser mayor a 0.';
|
||||
return serviceResult;
|
||||
}
|
||||
if (
|
||||
updateConfiguracionDto.tolerancia !== undefined &&
|
||||
updateConfiguracionDto.tolerancia < 0
|
||||
) {
|
||||
serviceResult.message = 'La tolerancia no puede ser negativa.';
|
||||
return serviceResult;
|
||||
}
|
||||
if (
|
||||
updateConfiguracionDto.zonaHoraria !== undefined &&
|
||||
!ZONA_HORA_RE.test(updateConfiguracionDto.zonaHoraria)
|
||||
) {
|
||||
serviceResult.message =
|
||||
'Zona horaria inválida (use ±HH:MM, p. ej. -04:00).';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
const clean: Partial<Configuracion> = {};
|
||||
if (updateConfiguracionDto.lat !== undefined) clean.lat = updateConfiguracionDto.lat;
|
||||
|
|
@ -88,6 +121,12 @@ export class ConfiguracionService {
|
|||
if (updateConfiguracionDto.distancia !== undefined) {
|
||||
clean.distancia = updateConfiguracionDto.distancia;
|
||||
}
|
||||
if (updateConfiguracionDto.tolerancia !== undefined) {
|
||||
clean.tolerancia = updateConfiguracionDto.tolerancia;
|
||||
}
|
||||
if (updateConfiguracionDto.zonaHoraria !== undefined) {
|
||||
clean.zonaHoraria = updateConfiguracionDto.zonaHoraria;
|
||||
}
|
||||
if (updateConfiguracionDto.openwaSessionId !== undefined) {
|
||||
clean.openwaSessionId = updateConfiguracionDto.openwaSessionId;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,17 @@
|
|||
import { ApiProperty } from '@nestjs/swagger';
|
||||
import { IsNotEmpty, IsNumber, IsOptional, IsString } from 'class-validator';
|
||||
import {
|
||||
IsInt,
|
||||
IsNotEmpty,
|
||||
IsNumber,
|
||||
IsOptional,
|
||||
IsString,
|
||||
Matches,
|
||||
Min,
|
||||
} from 'class-validator';
|
||||
import {
|
||||
ZONA_HORA_DEFAULT,
|
||||
ZONA_HORA_RE,
|
||||
} from '../../../common/utils/zona-horaria.js';
|
||||
|
||||
export class ConfiguracionDto {
|
||||
@ApiProperty()
|
||||
|
|
@ -17,6 +29,32 @@ export class ConfiguracionDto {
|
|||
@IsNotEmpty()
|
||||
distancia: number;
|
||||
|
||||
@ApiProperty({
|
||||
required: false,
|
||||
default: 0,
|
||||
description:
|
||||
'Minutos de tolerancia tras la hora límite de ingreso (Atrasado).',
|
||||
example: 10,
|
||||
})
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(0)
|
||||
tolerancia?: number;
|
||||
|
||||
@ApiProperty({
|
||||
required: false,
|
||||
default: ZONA_HORA_DEFAULT,
|
||||
description:
|
||||
'Offset UTC de la organización para calcular Atrasados (±HH:MM).',
|
||||
example: '-04:00',
|
||||
})
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@Matches(ZONA_HORA_RE, {
|
||||
message: 'Zona horaria inválida (use ±HH:MM, p. ej. -04:00).',
|
||||
})
|
||||
zonaHoraria?: string;
|
||||
|
||||
@ApiProperty({ required: false, description: 'SessionId de OpenWA' })
|
||||
@IsString()
|
||||
@IsOptional()
|
||||
|
|
|
|||
|
|
@ -14,6 +14,20 @@ export class Configuracion {
|
|||
@Column('double precision')
|
||||
distancia: number;
|
||||
|
||||
/**
|
||||
* Minutos de tolerancia tras la hora límite de ingreso de la primera
|
||||
* reunión del servicio (0 = sin gracia). Ver `turno.limiteIngreso`.
|
||||
*/
|
||||
@Column({ type: 'int', default: 0 })
|
||||
tolerancia: number;
|
||||
|
||||
/**
|
||||
* Offset UTC de la organización (`±HH:MM`, p. ej. `-04:00` Bolivia) para
|
||||
* calcular Atrasado/Presente sin depender de la zona del servidor.
|
||||
*/
|
||||
@Column({ type: 'varchar', default: '-04:00' })
|
||||
zonaHoraria: string;
|
||||
|
||||
/** SessionId de OpenWA (Easy API). Si es null se usa OPENWA_SESSION_ID de .env */
|
||||
@Column({ type: 'varchar', nullable: true })
|
||||
openwaSessionId?: string | null;
|
||||
|
|
|
|||
527
src/modules/mantenimiento/backup.service.ts
Normal file
527
src/modules/mantenimiento/backup.service.ts
Normal file
|
|
@ -0,0 +1,527 @@
|
|||
import { existsSync, mkdirSync, statSync, unlinkSync } from 'fs';
|
||||
import { readFile, writeFile } from 'fs/promises';
|
||||
import { basename, join } from 'path';
|
||||
import { spawn } from 'child_process';
|
||||
import { InjectRepository } from '@nestjs/typeorm';
|
||||
import { Repository } from 'typeorm';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { Asistencia } from '../asistencia/entities/asistencia.entity.js';
|
||||
import { CodigoOtp } from '../codigo-otp/entities/codigo-otp.entity.js';
|
||||
import { Dispositivo } from '../dispositivo/entities/dispositivo.entity.js';
|
||||
import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js';
|
||||
import { Equipo } from '../equipo/entities/equipo.entity.js';
|
||||
import { Persona } from '../persona/entities/persona.entity.js';
|
||||
import { Reemplazo } from '../reemplazo/entities/reemplazo.entity.js';
|
||||
import { ServicioEquipo } from '../servicio-equipo/entities/servicio-equipo.entity.js';
|
||||
import { ServicioTurno } from '../servicio-turno/entities/servicio-turno.entity.js';
|
||||
import { Servicio } from '../servicio/entities/servicio.entity.js';
|
||||
import { SolicitudApoyo } from '../solicitud-apoyo/entities/solicitud-apoyo.entity.js';
|
||||
import { Turno } from '../turno/entities/turno.entity.js';
|
||||
import {
|
||||
defaultServiceResult,
|
||||
ServiceResult,
|
||||
} from '../../common/interfaces/service.result.js';
|
||||
import { Backup } from './entities/backup.entity.js';
|
||||
import { TipoBackup } from './dto/backup.dto.js';
|
||||
|
||||
interface TablaDump {
|
||||
nombre: string;
|
||||
repo: Repository<any>;
|
||||
fragmentos: Partial<Record<string, string>>;
|
||||
}
|
||||
|
||||
const DIR_BACKUPS = 'backups';
|
||||
|
||||
/**
|
||||
* Respaldos `.sql` (solo Developer).
|
||||
*
|
||||
* - **completo**: `pg_dump` plan de toda la BD (schema + datos).
|
||||
* - **selectivo**: `INSERT`s de las mismas categorías/matriz que la purga.
|
||||
* - Archivos en `backups/` (NO en `uploads/`: no se sirven estáticos).
|
||||
* - Restaurar exige `confirmacion: 'RESTAURAR'` y usa `psql -f`.
|
||||
*/
|
||||
export class BackupService {
|
||||
constructor(
|
||||
@InjectRepository(Asistencia)
|
||||
private asistenciaRepo: Repository<Asistencia>,
|
||||
@InjectRepository(Reemplazo) private reemplazoRepo: Repository<Reemplazo>,
|
||||
@InjectRepository(SolicitudApoyo)
|
||||
private solicitudApoyoRepo: Repository<SolicitudApoyo>,
|
||||
@InjectRepository(EquipoPersona)
|
||||
private equipoPersonaRepo: Repository<EquipoPersona>,
|
||||
@InjectRepository(CodigoOtp) private codigoOtpRepo: Repository<CodigoOtp>,
|
||||
@InjectRepository(Dispositivo)
|
||||
private dispositivoRepo: Repository<Dispositivo>,
|
||||
@InjectRepository(ServicioEquipo)
|
||||
private servicioEquipoRepo: Repository<ServicioEquipo>,
|
||||
@InjectRepository(ServicioTurno)
|
||||
private servicioTurnoRepo: Repository<ServicioTurno>,
|
||||
@InjectRepository(Equipo) private equipoRepo: Repository<Equipo>,
|
||||
@InjectRepository(Servicio) private servicioRepo: Repository<Servicio>,
|
||||
@InjectRepository(Turno) private turnoRepo: Repository<Turno>,
|
||||
@InjectRepository(Persona) private personaRepo: Repository<Persona>,
|
||||
@InjectRepository(Backup) private backupRepo: Repository<Backup>,
|
||||
private config: ConfigService,
|
||||
) {}
|
||||
|
||||
private get dir(): string {
|
||||
const dir = join(process.cwd(), DIR_BACKUPS);
|
||||
if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
|
||||
return dir;
|
||||
}
|
||||
|
||||
private dbEnv(): NodeJS.ProcessEnv {
|
||||
return {
|
||||
...process.env,
|
||||
PGHOST: this.config.get<string>('DB_HOST', 'localhost'),
|
||||
PGPORT: this.config.get<string>('DB_PORT', '5432'),
|
||||
PGUSER: this.config.get<string>('DB_USER', 'postgres'),
|
||||
PGPASSWORD: this.config.get<string>('DB_PASSWORD', 'postgres'),
|
||||
PGDATABASE: this.config.get<string>('DB_NAME', 'min_ser'),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Resuelve el binario de PostgreSQL: `PG_DUMP_BIN` / `PSQL_BIN` en .env,
|
||||
* luego PATH, luego rutas comunes (pgAdmin en macOS).
|
||||
*/
|
||||
private binario(nombre: string, envKey: string): string {
|
||||
const custom = this.config.get<string>(envKey);
|
||||
if (custom && existsSync(custom)) return custom;
|
||||
|
||||
const enPath = this.queEstaEnPath(nombre);
|
||||
if (enPath) return enPath;
|
||||
|
||||
const candidatos = [
|
||||
`/Applications/pgAdmin 4.app/Contents/SharedSupport/${nombre}`,
|
||||
`/usr/local/bin/${nombre}`,
|
||||
`/opt/homebrew/bin/${nombre}`,
|
||||
`/usr/bin/${nombre}`,
|
||||
];
|
||||
for (const c of candidatos) {
|
||||
if (existsSync(c)) return c;
|
||||
}
|
||||
throw new Error(
|
||||
`No se encontró \`${nombre}\`. Instalá PostgreSQL client o definí ${envKey} en .env.`,
|
||||
);
|
||||
}
|
||||
|
||||
private queEstaEnPath(nombre: string): string | null {
|
||||
const path = process.env.PATH ?? '';
|
||||
for (const dir of path.split(':')) {
|
||||
if (!dir) continue;
|
||||
const c = join(dir, nombre);
|
||||
if (existsSync(c)) return c;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private ejecutar(
|
||||
bin: string,
|
||||
args: string[],
|
||||
): Promise<{ code: number; stdout: string; stderr: string }> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const child = spawn(bin, args, { env: this.dbEnv() });
|
||||
let stdout = '';
|
||||
let stderr = '';
|
||||
child.stdout.on('data', (d) => (stdout += d.toString()));
|
||||
child.stderr.on('data', (d) => (stderr += d.toString()));
|
||||
child.on('error', reject);
|
||||
child.on('close', (code) =>
|
||||
resolve({ code: code ?? -1, stdout, stderr }),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
/// Orden = orden de purga (hijos primero). Mismos fragmentos que MantenimientoService.
|
||||
private tablas(): TablaDump[] {
|
||||
return [
|
||||
{
|
||||
nombre: 'asistencia',
|
||||
repo: this.asistenciaRepo,
|
||||
fragmentos: {
|
||||
equipos: '"idEquipo" IS NOT NULL',
|
||||
servicios: '"idServicio" IS NOT NULL',
|
||||
personas: '"idPersona" IS NOT NULL',
|
||||
},
|
||||
},
|
||||
{
|
||||
nombre: 'reemplazo',
|
||||
repo: this.reemplazoRepo,
|
||||
fragmentos: {
|
||||
equipos: '"idEquipo" IS NOT NULL',
|
||||
servicios: '"idServicio" IS NOT NULL',
|
||||
personas:
|
||||
'("idPersonaTitular" IS NOT NULL OR "idPersonaReemplazo" IS NOT NULL)',
|
||||
},
|
||||
},
|
||||
{
|
||||
nombre: 'solicitud_apoyo',
|
||||
repo: this.solicitudApoyoRepo,
|
||||
fragmentos: {
|
||||
equipos: '"idEquipo" IS NOT NULL',
|
||||
servicios: '"idServicio" IS NOT NULL',
|
||||
},
|
||||
},
|
||||
{
|
||||
nombre: 'equipo_persona',
|
||||
repo: this.equipoPersonaRepo,
|
||||
fragmentos: {
|
||||
equipos: '"idEquipo" IS NOT NULL',
|
||||
personas: '"idPersona" IS NOT NULL',
|
||||
},
|
||||
},
|
||||
{
|
||||
nombre: 'codigo_otp',
|
||||
repo: this.codigoOtpRepo,
|
||||
fragmentos: { personas: '"idPersona" IS NOT NULL' },
|
||||
},
|
||||
{
|
||||
nombre: 'dispositivo',
|
||||
repo: this.dispositivoRepo,
|
||||
fragmentos: { personas: '"idPersona" IS NOT NULL' },
|
||||
},
|
||||
{
|
||||
nombre: 'servicio_equipo',
|
||||
repo: this.servicioEquipoRepo,
|
||||
fragmentos: {
|
||||
equipos: '"idEquipo" IS NOT NULL',
|
||||
servicios: '"idServicio" IS NOT NULL',
|
||||
},
|
||||
},
|
||||
{
|
||||
nombre: 'servicio_turno',
|
||||
repo: this.servicioTurnoRepo,
|
||||
fragmentos: {
|
||||
servicios: '"idServicio" IS NOT NULL',
|
||||
turnos: '"idTurno" IS NOT NULL',
|
||||
},
|
||||
},
|
||||
{
|
||||
nombre: 'equipo',
|
||||
repo: this.equipoRepo,
|
||||
fragmentos: { equipos: '1 = 1' },
|
||||
},
|
||||
{
|
||||
nombre: 'servicio',
|
||||
repo: this.servicioRepo,
|
||||
fragmentos: { servicios: '1 = 1' },
|
||||
},
|
||||
{
|
||||
nombre: 'turno',
|
||||
repo: this.turnoRepo,
|
||||
fragmentos: { turnos: '1 = 1' },
|
||||
},
|
||||
{
|
||||
nombre: 'persona',
|
||||
repo: this.personaRepo,
|
||||
fragmentos: { personas: '1 = 1' },
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
private whereDe(tabla: TablaDump, categorias: string[]): string | null {
|
||||
const partes = categorias
|
||||
.map((c) => tabla.fragmentos[c])
|
||||
.filter((f): f is string => Boolean(f));
|
||||
if (partes.length === 0) return null;
|
||||
return partes.length === 1 ? partes[0] : `(${partes.join(' OR ')})`;
|
||||
}
|
||||
|
||||
private serializar(valor: unknown): string {
|
||||
if (valor === null || valor === undefined) return 'NULL';
|
||||
if (typeof valor === 'number') return String(valor);
|
||||
if (typeof valor === 'boolean') return valor ? 'TRUE' : 'FALSE';
|
||||
if (valor instanceof Date) return `'${valor.toISOString()}'`;
|
||||
if (typeof valor === 'object') {
|
||||
return `'${JSON.stringify(valor).replace(/'/g, "''")}'::jsonb`;
|
||||
}
|
||||
return `'${String(valor).replace(/'/g, "''")}'`;
|
||||
}
|
||||
|
||||
/// SELECT de las filas de la categoría → script `.sql` con BEGIN/COMMIT.
|
||||
private async scriptSelectivo(categorias: string[]): Promise<string> {
|
||||
const partes: string[] = [
|
||||
'-- Respaldo selectivo min-ser (mismas categorías que la purga)',
|
||||
`-- categorias: ${categorias.join(', ')}`,
|
||||
'BEGIN;',
|
||||
'',
|
||||
];
|
||||
|
||||
for (const tabla of this.tablas()) {
|
||||
const where = this.whereDe(tabla, categorias);
|
||||
if (!where) continue;
|
||||
|
||||
const columnas = tabla.repo.metadata.columns.map(
|
||||
(c) => `"${c.databaseName}"`,
|
||||
);
|
||||
if (columnas.length === 0) continue;
|
||||
|
||||
const filas = await tabla.repo
|
||||
.createQueryBuilder('t')
|
||||
.where(where)
|
||||
.getRawMany();
|
||||
|
||||
partes.push(`-- tabla ${tabla.nombre}: ${filas.length} fila(s)`);
|
||||
for (const fila of filas) {
|
||||
const vals = tabla.repo.metadata.columns
|
||||
.map((c) => this.serializar(fila[c.databaseName]))
|
||||
.join(', ');
|
||||
partes.push(
|
||||
`INSERT INTO "${tabla.nombre}" (${columnas.join(', ')}) VALUES (${vals});`,
|
||||
);
|
||||
}
|
||||
partes.push('');
|
||||
}
|
||||
|
||||
partes.push('COMMIT;', '');
|
||||
return partes.join('\n');
|
||||
}
|
||||
|
||||
private async pgDumpCompleto(destino: string): Promise<void> {
|
||||
const bin = this.binario('pg_dump', 'PG_DUMP_BIN');
|
||||
const { code, stderr } = await this.ejecutar(bin, [
|
||||
'--no-owner',
|
||||
'--no-privileges',
|
||||
'--clean',
|
||||
'--if-exists',
|
||||
'-f',
|
||||
destino,
|
||||
]);
|
||||
if (code !== 0) {
|
||||
throw new Error(`pg_dump falló (código ${code}): ${stderr.trim()}`);
|
||||
}
|
||||
if (!existsSync(destino)) {
|
||||
throw new Error('pg_dump no creó el archivo de respaldo.');
|
||||
}
|
||||
}
|
||||
|
||||
private async psqlArchivo(ruta: string): Promise<void> {
|
||||
const bin = this.binario('psql', 'PSQL_BIN');
|
||||
const { code, stderr } = await this.ejecutar(bin, [
|
||||
'-v',
|
||||
'ON_ERROR_STOP=1',
|
||||
'-f',
|
||||
ruta,
|
||||
]);
|
||||
if (code !== 0) {
|
||||
throw new Error(`psql falló (código ${code}): ${stderr.trim()}`);
|
||||
}
|
||||
}
|
||||
|
||||
/// Crea la fila `Generando`, genera el `.sql` y la deja `Listo`/`Fallido`.
|
||||
async generar(
|
||||
tipo: TipoBackup,
|
||||
categorias: string[] | undefined,
|
||||
idPersona: string,
|
||||
): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
|
||||
if (tipo === 'selectivo' && (!categorias || categorias.length === 0)) {
|
||||
serviceResult.message =
|
||||
'Elegí al menos una categoría para el respaldo selectivo.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
const marca = new Date().toISOString().replace(/[:.]/g, '-');
|
||||
const nombre =
|
||||
tipo === 'completo'
|
||||
? `completo-${marca}.sql`
|
||||
: `selectivo-${[...(categorias ?? [])].sort().join('-')}-${marca}.sql`;
|
||||
const destino = join(this.dir, nombre);
|
||||
|
||||
const fila = await this.backupRepo.save(
|
||||
this.backupRepo.create({
|
||||
nombreArchivo: nombre,
|
||||
tipo,
|
||||
categorias: tipo === 'selectivo' ? [...(categorias ?? [])] : null,
|
||||
tamano: 0,
|
||||
estado: 'Generando',
|
||||
origen: 'generado',
|
||||
generadoPor: idPersona,
|
||||
}),
|
||||
);
|
||||
|
||||
try {
|
||||
if (tipo === 'completo') {
|
||||
await this.pgDumpCompleto(destino);
|
||||
} else {
|
||||
const sql = await this.scriptSelectivo(categorias ?? []);
|
||||
await writeFile(destino, sql, 'utf8');
|
||||
}
|
||||
|
||||
const tamano = statSync(destino).size;
|
||||
fila.estado = 'Listo';
|
||||
fila.tamano = tamano;
|
||||
fila.error = null;
|
||||
await this.backupRepo.save(fila);
|
||||
|
||||
serviceResult.boolean = true;
|
||||
serviceResult.message = `Respaldo generado: ${nombre} (${tamano} bytes).`;
|
||||
serviceResult.number = 1;
|
||||
serviceResult.object = this.publico(fila);
|
||||
return serviceResult;
|
||||
} catch (error) {
|
||||
const msg = error instanceof Error ? error.message : String(error);
|
||||
fila.estado = 'Fallido';
|
||||
fila.error = msg;
|
||||
await this.backupRepo.save(fila);
|
||||
serviceResult.message = `No se pudo generar el respaldo: ${msg}`;
|
||||
serviceResult.object = this.publico(fila);
|
||||
return serviceResult;
|
||||
}
|
||||
}
|
||||
|
||||
/// Lista de respaldos (más recientes primero).
|
||||
async listar(): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
const filas = await this.backupRepo.find({
|
||||
order: { generadoEn: 'DESC' },
|
||||
});
|
||||
serviceResult.boolean = true;
|
||||
serviceResult.message = `${filas.length} respaldo(s).`;
|
||||
serviceResult.number = filas.length;
|
||||
serviceResult.data = filas.map((f) => this.publico(f));
|
||||
serviceResult.object = { items: serviceResult.data };
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
/// Fila de un respaldo + ruta absoluta del archivo (para descarga/restaurar).
|
||||
async porId(
|
||||
idBackup: string,
|
||||
): Promise<{ fila: Backup; ruta: string } | null> {
|
||||
const fila = await this.backupRepo.findOne({ where: { idBackup } });
|
||||
if (!fila) return null;
|
||||
const ruta = join(this.dir, fila.nombreArchivo);
|
||||
if (!existsSync(ruta)) return null;
|
||||
return { fila, ruta };
|
||||
}
|
||||
|
||||
async restaurar(idBackup: string): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
const encontrado = await this.porId(idBackup);
|
||||
if (!encontrado) {
|
||||
serviceResult.message =
|
||||
'Respaldo no encontrado (o el archivo falta en disco).';
|
||||
return serviceResult;
|
||||
}
|
||||
if (encontrado.fila.estado !== 'Listo') {
|
||||
serviceResult.message = `Solo se puede restaurar un respaldo Listo (estado actual: ${encontrado.fila.estado}).`;
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
try {
|
||||
await this.psqlArchivo(encontrado.ruta);
|
||||
serviceResult.boolean = true;
|
||||
serviceResult.message =
|
||||
`Restauración completada desde ${encontrado.fila.nombreArchivo}. ` +
|
||||
'La base fue sobrescrita con el contenido del respaldo.';
|
||||
serviceResult.number = 1;
|
||||
serviceResult.object = this.publico(encontrado.fila);
|
||||
return serviceResult;
|
||||
} catch (error) {
|
||||
const msg = error instanceof Error ? error.message : String(error);
|
||||
serviceResult.message = `No se pudo restaurar: ${msg}`;
|
||||
return serviceResult;
|
||||
}
|
||||
}
|
||||
|
||||
/// Borra el archivo de disco y la fila `backup` (no toca las tablas de datos).
|
||||
async eliminar(idBackup: string): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
const fila = await this.backupRepo.findOne({ where: { idBackup } });
|
||||
if (!fila) {
|
||||
serviceResult.message = 'Respaldo no encontrado.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
const ruta = join(this.dir, fila.nombreArchivo);
|
||||
try {
|
||||
if (existsSync(ruta)) {
|
||||
unlinkSync(ruta);
|
||||
}
|
||||
await this.backupRepo.delete({ idBackup });
|
||||
serviceResult.boolean = true;
|
||||
serviceResult.message = `Respaldo eliminado: ${fila.nombreArchivo}.`;
|
||||
serviceResult.number = 1;
|
||||
serviceResult.object = this.publico(fila);
|
||||
return serviceResult;
|
||||
} catch (error) {
|
||||
const msg = error instanceof Error ? error.message : String(error);
|
||||
serviceResult.message = `No se pudo eliminar el respaldo: ${msg}`;
|
||||
return serviceResult;
|
||||
}
|
||||
}
|
||||
|
||||
/// Guarda un `.sql` subido desde otro server como respaldo `subido`.
|
||||
async cargar(
|
||||
buffer: Buffer,
|
||||
nombreOriginal: string,
|
||||
idPersona: string,
|
||||
): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
|
||||
const base = basename(nombreOriginal || 'cargado.sql');
|
||||
if (!base.toLowerCase().endsWith('.sql')) {
|
||||
serviceResult.message = 'El archivo debe tener extensión .sql.';
|
||||
return serviceResult;
|
||||
}
|
||||
if (buffer.length === 0) {
|
||||
serviceResult.message = 'El archivo está vacío.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
const marca = new Date().toISOString().replace(/[:.]/g, '-');
|
||||
const nombre = `subido-${marca}-${base.replace(/[^\w.-]+/g, '_')}`;
|
||||
const destino = join(this.dir, nombre);
|
||||
await writeFile(destino, buffer);
|
||||
|
||||
const fila = await this.backupRepo.save(
|
||||
this.backupRepo.create({
|
||||
nombreArchivo: nombre,
|
||||
tipo: 'completo',
|
||||
categorias: null,
|
||||
tamano: buffer.length,
|
||||
estado: 'Listo',
|
||||
origen: 'subido',
|
||||
error: null,
|
||||
generadoPor: idPersona,
|
||||
}),
|
||||
);
|
||||
|
||||
serviceResult.boolean = true;
|
||||
serviceResult.message = `Respaldo cargado: ${nombre} (${buffer.length} bytes).`;
|
||||
serviceResult.number = 1;
|
||||
serviceResult.object = this.publico(fila);
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
/// JSON seguro para la API (sin ruta interna).
|
||||
private publico(fila: Backup): Record<string, unknown> {
|
||||
return {
|
||||
idBackup: fila.idBackup,
|
||||
nombreArchivo: fila.nombreArchivo,
|
||||
tipo: fila.tipo,
|
||||
categorias: fila.categorias ?? null,
|
||||
tamano: fila.tamano,
|
||||
estado: fila.estado,
|
||||
origen: fila.origen,
|
||||
error: fila.error ?? null,
|
||||
generadoPor: fila.generadoPor,
|
||||
generadoEn:
|
||||
fila.generadoEn instanceof Date
|
||||
? fila.generadoEn.toISOString()
|
||||
: fila.generadoEn,
|
||||
};
|
||||
}
|
||||
|
||||
/// Bytes del archivo para la descarga autenticada.
|
||||
async leerArchivo(
|
||||
idBackup: string,
|
||||
): Promise<{ nombre: string; bytes: Buffer } | null> {
|
||||
const encontrado = await this.porId(idBackup);
|
||||
if (!encontrado) return null;
|
||||
const bytes = await readFile(encontrado.ruta);
|
||||
return { nombre: encontrado.fila.nombreArchivo, bytes };
|
||||
}
|
||||
}
|
||||
55
src/modules/mantenimiento/dto/backup.dto.ts
Normal file
55
src/modules/mantenimiento/dto/backup.dto.ts
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
import { ApiProperty } from '@nestjs/swagger';
|
||||
import {
|
||||
ArrayNotEmpty,
|
||||
IsArray,
|
||||
IsIn,
|
||||
IsOptional,
|
||||
IsString,
|
||||
} from 'class-validator';
|
||||
import { PURGA_CATEGORIAS } from './purga.dto.js';
|
||||
|
||||
/// Tipos de respaldo (solo Developer, PlanFlutter §7.10).
|
||||
export const TIPOS_BACKUP = ['completo', 'selectivo'] as const;
|
||||
export type TipoBackup = (typeof TIPOS_BACKUP)[number];
|
||||
|
||||
export class BackupDto {
|
||||
@ApiProperty({
|
||||
enum: TIPOS_BACKUP,
|
||||
example: 'selectivo',
|
||||
description:
|
||||
'completo = pg_dump de toda la BD; selectivo = solo las categorías.',
|
||||
})
|
||||
@IsIn([...TIPOS_BACKUP])
|
||||
tipo: TipoBackup;
|
||||
|
||||
@ApiProperty({
|
||||
type: [String],
|
||||
enum: PURGA_CATEGORIAS,
|
||||
example: ['personas'],
|
||||
required: false,
|
||||
description: 'Obligatorio cuando tipo = selectivo (mismas que la purga).',
|
||||
})
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@ArrayNotEmpty()
|
||||
@IsIn([...PURGA_CATEGORIAS], { each: true })
|
||||
categorias?: string[];
|
||||
}
|
||||
|
||||
export class RestaurarDto {
|
||||
@ApiProperty({
|
||||
description: 'Debe ser exactamente "RESTAURAR".',
|
||||
example: 'RESTAURAR',
|
||||
})
|
||||
@IsString()
|
||||
confirmacion: string;
|
||||
}
|
||||
|
||||
export class EliminarBackupDto {
|
||||
@ApiProperty({
|
||||
description: 'Debe ser exactamente "ELIMINAR".',
|
||||
example: 'ELIMINAR',
|
||||
})
|
||||
@IsString()
|
||||
confirmacion: string;
|
||||
}
|
||||
44
src/modules/mantenimiento/entities/backup.entity.ts
Normal file
44
src/modules/mantenimiento/entities/backup.entity.ts
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
|
||||
|
||||
/** Metadato de un respaldo `.sql` en disco (`backups/`, fuera de `uploads/`). */
|
||||
@Entity('backup')
|
||||
export class Backup {
|
||||
@PrimaryGeneratedColumn('uuid')
|
||||
idBackup: string;
|
||||
|
||||
/** Nombre del archivo bajo `backups/` (p. ej. `completo-….sql`). */
|
||||
@Column({ type: 'varchar' })
|
||||
nombreArchivo: string;
|
||||
|
||||
/** `completo` = pg_dump de toda la BD; `selectivo` = solo categorías. */
|
||||
@Column({ type: 'varchar' })
|
||||
tipo: string;
|
||||
|
||||
/** Categorías del respaldo selectivo (`null` si es completo). */
|
||||
@Column({ type: 'simple-array', nullable: true })
|
||||
categorias?: string[] | null;
|
||||
|
||||
/** Tamaño en bytes del archivo. */
|
||||
@Column({ type: 'bigint', transformer: {
|
||||
to: (v: number) => v,
|
||||
from: (v: string | number) => Number(v),
|
||||
} })
|
||||
tamano: number;
|
||||
|
||||
@Column({ type: 'varchar' })
|
||||
estado: string;
|
||||
|
||||
/** `generado` = pg_dump/SELECT en este server; `subido` = upload. */
|
||||
@Column({ type: 'varchar' })
|
||||
origen: string;
|
||||
|
||||
/** Mensaje de error si `estado = 'Fallido'`. */
|
||||
@Column({ type: 'text', nullable: true })
|
||||
error?: string | null;
|
||||
|
||||
@Column({ type: 'uuid' })
|
||||
generadoPor: string;
|
||||
|
||||
@Column({ type: 'timestamptz', default: () => 'now()' })
|
||||
generadoEn: Date;
|
||||
}
|
||||
|
|
@ -1,20 +1,54 @@
|
|||
import { Body, Controller, HttpStatus, Post } from '@nestjs/common';
|
||||
import {
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
Get,
|
||||
HttpStatus,
|
||||
Param,
|
||||
Post,
|
||||
Req,
|
||||
Res,
|
||||
UploadedFile,
|
||||
UseInterceptors,
|
||||
} from '@nestjs/common';
|
||||
import { FileInterceptor } from '@nestjs/platform-express';
|
||||
import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
|
||||
import type { Response } from 'express';
|
||||
import { diskStorage } from 'multer';
|
||||
import { existsSync, mkdirSync } from 'fs';
|
||||
import { basename, extname, join } from 'path';
|
||||
import { Autorizacion } from '../../common/decorators/autorizacion.decorator.js';
|
||||
import { Autorizacion as AutorizacionEnum } from '../../common/enums/rol.enum.js';
|
||||
import {
|
||||
ApiResult,
|
||||
defaultApiResult,
|
||||
} from '../../common/interfaces/api.result.js';
|
||||
import type { AuthRequest } from '../../common/utils/auth-user.js';
|
||||
import { getAuthUser } from '../../common/utils/auth-user.js';
|
||||
import { PurgaDto } from './dto/purga.dto.js';
|
||||
import {
|
||||
BackupDto,
|
||||
EliminarBackupDto,
|
||||
RestaurarDto,
|
||||
} from './dto/backup.dto.js';
|
||||
import { MantenimientoService } from './mantenimiento.service.js';
|
||||
import { BackupService } from './backup.service.js';
|
||||
import { routeMantenimiento } from './mantenimiento.router.js';
|
||||
|
||||
function dirBackups(): string {
|
||||
const dir = join(process.cwd(), 'backups');
|
||||
if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
|
||||
return dir;
|
||||
}
|
||||
|
||||
@ApiTags('mantenimiento')
|
||||
@ApiBearerAuth()
|
||||
@Controller('mantenimiento')
|
||||
export class MantenimientoController {
|
||||
constructor(private readonly mantenimientoService: MantenimientoService) {}
|
||||
constructor(
|
||||
private readonly mantenimientoService: MantenimientoService,
|
||||
private readonly backupService: BackupService,
|
||||
) {}
|
||||
|
||||
/// Borrado físico total por categoría: dryRun cuenta; ejecutar exige
|
||||
/// `confirmacion === 'ELIMINAR'`.
|
||||
|
|
@ -59,4 +93,348 @@ export class MantenimientoController {
|
|||
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
/// Cuántas personas están `Inhabilitado` (marca de reportes).
|
||||
@Get('personas-inhabilitadas')
|
||||
@Autorizacion(AutorizacionEnum.Developer)
|
||||
async contarInhabilitadas(): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeMantenimiento.contarInhabilitadas.title,
|
||||
routeMantenimiento.contarInhabilitadas.route,
|
||||
);
|
||||
try {
|
||||
const result = await this.mantenimientoService.contarInhabilitadas();
|
||||
apiResult.status = 'correct';
|
||||
apiResult.code = HttpStatus.OK;
|
||||
apiResult.message = result.message;
|
||||
apiResult.boolean = true;
|
||||
apiResult.rows = result.number;
|
||||
apiResult.data = [result.object];
|
||||
} catch (error) {
|
||||
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
apiResult.message = error.message;
|
||||
}
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
/// `Inhabilitado` → `Activo` en todas las personas (corrige reportes).
|
||||
@Post('activar-personas')
|
||||
@Autorizacion(AutorizacionEnum.Developer)
|
||||
async activarPersonas(): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeMantenimiento.activarInhabilitadas.title,
|
||||
routeMantenimiento.activarInhabilitadas.route,
|
||||
);
|
||||
try {
|
||||
const result = await this.mantenimientoService.activarInhabilitadas();
|
||||
apiResult.status = 'correct';
|
||||
apiResult.code = HttpStatus.OK;
|
||||
apiResult.message = result.message;
|
||||
apiResult.boolean = true;
|
||||
apiResult.rows = result.number;
|
||||
apiResult.data = [result.object];
|
||||
} catch (error) {
|
||||
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
apiResult.message = error.message;
|
||||
}
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
/// Mayúscula inicial por palabra en nombres/apellidos de todas las personas.
|
||||
@Post('normalizar-nombres')
|
||||
@Autorizacion(AutorizacionEnum.Developer)
|
||||
async normalizarNombres(): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeMantenimiento.normalizarNombres.title,
|
||||
routeMantenimiento.normalizarNombres.route,
|
||||
);
|
||||
try {
|
||||
const result = await this.mantenimientoService.normalizarNombres();
|
||||
apiResult.status = 'correct';
|
||||
apiResult.code = HttpStatus.OK;
|
||||
apiResult.message = result.message;
|
||||
apiResult.boolean = true;
|
||||
apiResult.rows = result.number;
|
||||
apiResult.data = [result.object];
|
||||
} catch (error) {
|
||||
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
apiResult.message = error.message;
|
||||
}
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
/// Genera un `.sql` (completo = pg_dump; selectivo = INSERTs por categoría).
|
||||
@Post('backup')
|
||||
@Autorizacion(AutorizacionEnum.Developer)
|
||||
async generarBackup(
|
||||
@Req() req: AuthRequest,
|
||||
@Body() dto: BackupDto,
|
||||
): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeMantenimiento.backupGenerar.title,
|
||||
routeMantenimiento.backupGenerar.route,
|
||||
);
|
||||
try {
|
||||
const user = getAuthUser(req);
|
||||
if (!user) {
|
||||
apiResult.code = HttpStatus.UNAUTHORIZED;
|
||||
apiResult.message = 'Token inválido.';
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
if (dto.tipo === 'selectivo' && !dto.categorias?.length) {
|
||||
apiResult.code = HttpStatus.BAD_REQUEST;
|
||||
apiResult.message =
|
||||
'Elegí al menos una categoría para el respaldo selectivo.';
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
const result = await this.backupService.generar(
|
||||
dto.tipo,
|
||||
dto.categorias,
|
||||
user.idPersona,
|
||||
);
|
||||
|
||||
if (result.boolean) {
|
||||
apiResult.status = 'correct';
|
||||
apiResult.code = HttpStatus.OK;
|
||||
apiResult.message = result.message;
|
||||
apiResult.boolean = true;
|
||||
apiResult.rows = result.number;
|
||||
apiResult.data = [result.object];
|
||||
} else {
|
||||
apiResult.code = HttpStatus.BAD_REQUEST;
|
||||
apiResult.message = result.message;
|
||||
if (result.object) apiResult.data = [result.object];
|
||||
}
|
||||
} catch (error) {
|
||||
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
apiResult.message = error.message;
|
||||
}
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
/// Lista de respaldos (fecha, tipo, tamaño, estado, origen).
|
||||
@Get('backup')
|
||||
@Autorizacion(AutorizacionEnum.Developer)
|
||||
async listarBackups(): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeMantenimiento.backupListar.title,
|
||||
routeMantenimiento.backupListar.route,
|
||||
);
|
||||
try {
|
||||
const result = await this.backupService.listar();
|
||||
apiResult.status = 'correct';
|
||||
apiResult.code = HttpStatus.OK;
|
||||
apiResult.message = result.message;
|
||||
apiResult.boolean = true;
|
||||
apiResult.rows = result.number;
|
||||
// Envelope de lista: un solo objeto `{ items: [...] }` en data[0]
|
||||
// (ApiClient solo expone el primer elemento como `objeto`).
|
||||
apiResult.data = [{ items: result.data ?? [] }];
|
||||
} catch (error) {
|
||||
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
apiResult.message = error.message;
|
||||
}
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
/// Descarga autenticada del `.sql` (no está en `/uploads` estático).
|
||||
@Get('backup/:idBackup/descarga')
|
||||
@Autorizacion(AutorizacionEnum.Developer)
|
||||
async descargarBackup(
|
||||
@Param('idBackup') idBackup: string,
|
||||
@Res() res: Response,
|
||||
): Promise<void> {
|
||||
try {
|
||||
const archivo = await this.backupService.leerArchivo(idBackup);
|
||||
if (!archivo) {
|
||||
res.status(HttpStatus.NOT_FOUND).json({
|
||||
title: routeMantenimiento.backupDescarga.title,
|
||||
route: routeMantenimiento.backupDescarga.route,
|
||||
status: '',
|
||||
code: 404,
|
||||
message: 'Respaldo no encontrado.',
|
||||
boolean: false,
|
||||
rows: 0,
|
||||
data: [],
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
res
|
||||
.status(HttpStatus.OK)
|
||||
.set({
|
||||
'Content-Type': 'application/sql; charset=utf-8',
|
||||
'Content-Disposition': `attachment; filename="${archivo.nombre}"`,
|
||||
'Content-Length': String(archivo.bytes.length),
|
||||
})
|
||||
.send(archivo.bytes);
|
||||
} catch (error) {
|
||||
res.status(error.status ?? HttpStatus.INTERNAL_SERVER_ERROR).json({
|
||||
title: routeMantenimiento.backupDescarga.title,
|
||||
route: routeMantenimiento.backupDescarga.route,
|
||||
status: '',
|
||||
code: error.status ?? 500,
|
||||
message: error.message,
|
||||
boolean: false,
|
||||
rows: 0,
|
||||
data: [],
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/// Restaura con `psql -f`; exige `confirmacion: 'RESTAURAR'`.
|
||||
@Post('backup/:idBackup/restaurar')
|
||||
@Autorizacion(AutorizacionEnum.Developer)
|
||||
async restaurarBackup(
|
||||
@Param('idBackup') idBackup: string,
|
||||
@Body() dto: RestaurarDto,
|
||||
): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeMantenimiento.backupRestaurar.title,
|
||||
routeMantenimiento.backupRestaurar.route,
|
||||
);
|
||||
try {
|
||||
if (dto.confirmacion !== 'RESTAURAR') {
|
||||
apiResult.code = HttpStatus.BAD_REQUEST;
|
||||
apiResult.message =
|
||||
'Confirmación incorrecta: escribí RESTAURAR para restaurar.';
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
const result = await this.backupService.restaurar(idBackup);
|
||||
if (result.boolean) {
|
||||
apiResult.status = 'correct';
|
||||
apiResult.code = HttpStatus.OK;
|
||||
apiResult.message = result.message;
|
||||
apiResult.boolean = true;
|
||||
apiResult.rows = result.number;
|
||||
apiResult.data = [result.object];
|
||||
} else {
|
||||
apiResult.code = HttpStatus.BAD_REQUEST;
|
||||
apiResult.message = result.message;
|
||||
}
|
||||
} catch (error) {
|
||||
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
apiResult.message = error.message;
|
||||
}
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
/// Elimina el archivo `.sql` y la fila; exige `confirmacion: 'ELIMINAR'`.
|
||||
@Delete('backup/:idBackup')
|
||||
@Autorizacion(AutorizacionEnum.Developer)
|
||||
async eliminarBackup(
|
||||
@Param('idBackup') idBackup: string,
|
||||
@Body() dto: EliminarBackupDto,
|
||||
): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeMantenimiento.backupEliminar.title,
|
||||
routeMantenimiento.backupEliminar.route,
|
||||
);
|
||||
try {
|
||||
if (dto?.confirmacion !== 'ELIMINAR') {
|
||||
apiResult.code = HttpStatus.BAD_REQUEST;
|
||||
apiResult.message =
|
||||
'Confirmación incorrecta: escribí ELIMINAR para borrar el respaldo.';
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
const result = await this.backupService.eliminar(idBackup);
|
||||
if (result.boolean) {
|
||||
apiResult.status = 'correct';
|
||||
apiResult.code = HttpStatus.OK;
|
||||
apiResult.message = result.message;
|
||||
apiResult.boolean = true;
|
||||
apiResult.rows = result.number;
|
||||
apiResult.data = [result.object];
|
||||
} else {
|
||||
apiResult.code = HttpStatus.BAD_REQUEST;
|
||||
apiResult.message = result.message;
|
||||
}
|
||||
} catch (error) {
|
||||
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
apiResult.message = error.message;
|
||||
}
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
/// Sube un `.sql` desde otro server (multipart campo `archivo`).
|
||||
@Post('backup/cargar')
|
||||
@Autorizacion(AutorizacionEnum.Developer)
|
||||
@UseInterceptors(
|
||||
FileInterceptor('archivo', {
|
||||
storage: diskStorage({
|
||||
destination: (_req, _file, callback) => {
|
||||
callback(null, dirBackups());
|
||||
},
|
||||
filename: (_req, file, callback) => {
|
||||
const ext = extname(file.originalname).toLowerCase() || '.sql';
|
||||
callback(
|
||||
null,
|
||||
`tmp-${Date.now()}-${basename(file.originalname, extname(file.originalname)).replace(/[^\w.-]+/g, '_')}${ext}`,
|
||||
);
|
||||
},
|
||||
}),
|
||||
limits: { fileSize: 512 * 1024 * 1024 },
|
||||
fileFilter: (_req, file, callback) => {
|
||||
if (!file.originalname.toLowerCase().endsWith('.sql')) {
|
||||
callback(
|
||||
new Error('El archivo debe tener extensión .sql.'),
|
||||
false,
|
||||
);
|
||||
return;
|
||||
}
|
||||
callback(null, true);
|
||||
},
|
||||
}),
|
||||
)
|
||||
async cargarBackup(
|
||||
@Req() req: AuthRequest,
|
||||
@UploadedFile() file?: Express.Multer.File,
|
||||
): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeMantenimiento.backupCargar.title,
|
||||
routeMantenimiento.backupCargar.route,
|
||||
);
|
||||
try {
|
||||
const user = getAuthUser(req);
|
||||
if (!user) {
|
||||
apiResult.code = HttpStatus.UNAUTHORIZED;
|
||||
apiResult.message = 'Token inválido.';
|
||||
return apiResult;
|
||||
}
|
||||
if (!file?.path || !file.filename) {
|
||||
apiResult.code = HttpStatus.BAD_REQUEST;
|
||||
apiResult.message = 'No se recibió el archivo .sql (campo "archivo").';
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
const { readFile, unlink } = await import('fs/promises');
|
||||
const buffer = await readFile(file.path);
|
||||
const result = await this.backupService.cargar(
|
||||
buffer,
|
||||
file.originalname,
|
||||
user.idPersona,
|
||||
);
|
||||
await unlink(file.path).catch(() => undefined);
|
||||
|
||||
if (result.boolean) {
|
||||
apiResult.status = 'correct';
|
||||
apiResult.code = HttpStatus.OK;
|
||||
apiResult.message = result.message;
|
||||
apiResult.boolean = true;
|
||||
apiResult.rows = result.number;
|
||||
apiResult.data = [result.object];
|
||||
} else {
|
||||
apiResult.code = HttpStatus.BAD_REQUEST;
|
||||
apiResult.message = result.message;
|
||||
}
|
||||
} catch (error) {
|
||||
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
apiResult.message = error.message;
|
||||
}
|
||||
return apiResult;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,8 +12,10 @@ import { ServicioTurno } from '../servicio-turno/entities/servicio-turno.entity.
|
|||
import { Servicio } from '../servicio/entities/servicio.entity.js';
|
||||
import { SolicitudApoyo } from '../solicitud-apoyo/entities/solicitud-apoyo.entity.js';
|
||||
import { Turno } from '../turno/entities/turno.entity.js';
|
||||
import { Backup } from './entities/backup.entity.js';
|
||||
import { MantenimientoController } from './mantenimiento.controller.js';
|
||||
import { MantenimientoService } from './mantenimiento.service.js';
|
||||
import { BackupService } from './backup.service.js';
|
||||
|
||||
@Module({
|
||||
imports: [
|
||||
|
|
@ -30,9 +32,10 @@ import { MantenimientoService } from './mantenimiento.service.js';
|
|||
Servicio,
|
||||
Turno,
|
||||
Persona,
|
||||
Backup,
|
||||
]),
|
||||
],
|
||||
controllers: [MantenimientoController],
|
||||
providers: [MantenimientoService],
|
||||
providers: [MantenimientoService, BackupService],
|
||||
})
|
||||
export class MantenimientoModule {}
|
||||
|
|
|
|||
|
|
@ -3,4 +3,40 @@ export const routeMantenimiento = {
|
|||
route: '[POST].../v1/mantenimiento/purga',
|
||||
title: 'Purga de datos (Developer)',
|
||||
},
|
||||
backupGenerar: {
|
||||
route: '[POST].../v1/mantenimiento/backup',
|
||||
title: 'Generar respaldo .sql (Developer)',
|
||||
},
|
||||
backupListar: {
|
||||
route: '[GET].../v1/mantenimiento/backup',
|
||||
title: 'Listar respaldos (Developer)',
|
||||
},
|
||||
backupDescarga: {
|
||||
route: '[GET].../v1/mantenimiento/backup/:idBackup/descarga',
|
||||
title: 'Descargar respaldo .sql (Developer)',
|
||||
},
|
||||
backupRestaurar: {
|
||||
route: '[POST].../v1/mantenimiento/backup/:idBackup/restaurar',
|
||||
title: 'Restaurar respaldo .sql (Developer)',
|
||||
},
|
||||
backupCargar: {
|
||||
route: '[POST].../v1/mantenimiento/backup/cargar',
|
||||
title: 'Cargar respaldo .sql (Developer)',
|
||||
},
|
||||
backupEliminar: {
|
||||
route: '[DELETE].../v1/mantenimiento/backup/:idBackup',
|
||||
title: 'Eliminar respaldo .sql (Developer)',
|
||||
},
|
||||
contarInhabilitadas: {
|
||||
route: '[GET].../v1/mantenimiento/personas-inhabilitadas',
|
||||
title: 'Contar personas inhabilitadas (Developer)',
|
||||
},
|
||||
activarInhabilitadas: {
|
||||
route: '[POST].../v1/mantenimiento/activar-personas',
|
||||
title: 'Reactivar personas inhabilitadas (Developer)',
|
||||
},
|
||||
normalizarNombres: {
|
||||
route: '[POST].../v1/mantenimiento/normalizar-nombres',
|
||||
title: 'Normalizar nombres/apellidos (Developer)',
|
||||
},
|
||||
};
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@ import { ServicioTurno } from '../servicio-turno/entities/servicio-turno.entity.
|
|||
import { Servicio } from '../servicio/entities/servicio.entity.js';
|
||||
import { SolicitudApoyo } from '../solicitud-apoyo/entities/solicitud-apoyo.entity.js';
|
||||
import { Turno } from '../turno/entities/turno.entity.js';
|
||||
import { EstadoGeneral } from '../../common/enums/estados.enum.js';
|
||||
import {
|
||||
defaultServiceResult,
|
||||
ServiceResult,
|
||||
|
|
@ -194,4 +195,96 @@ export class MantenimientoService {
|
|||
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
/// Personas con `estado = Inhabilitado` (marca por reporte).
|
||||
async contarInhabilitadas(): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
const n = await this.personaRepo.count({
|
||||
where: { estado: EstadoGeneral.Inhabilitado },
|
||||
});
|
||||
serviceResult.boolean = true;
|
||||
serviceResult.message = `${n} persona(s) inhabilitada(s).`;
|
||||
serviceResult.number = n;
|
||||
serviceResult.object = { inhabilitadas: n };
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
/**
|
||||
* Pasa `Inhabilitado` → `Activo` en todas las personas (corrige la
|
||||
* marca errónea de la subrutina de reportes; no toca Inactivo/Eliminado).
|
||||
*/
|
||||
async activarInhabilitadas(): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
const n = await this.personaRepo.count({
|
||||
where: { estado: EstadoGeneral.Inhabilitado },
|
||||
});
|
||||
|
||||
if (n === 0) {
|
||||
serviceResult.boolean = true;
|
||||
serviceResult.message = 'No hay personas inhabilitadas.';
|
||||
serviceResult.number = 0;
|
||||
serviceResult.object = { activadas: 0 };
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
await this.personaRepo
|
||||
.createQueryBuilder()
|
||||
.update(Persona)
|
||||
.set({ estado: EstadoGeneral.Activo })
|
||||
.where('estado = :estado', { estado: EstadoGeneral.Inhabilitado })
|
||||
.execute();
|
||||
|
||||
serviceResult.boolean = true;
|
||||
serviceResult.message = `${n} persona(s) reactivada(s) (Inhabilitado → Activo).`;
|
||||
serviceResult.number = n;
|
||||
serviceResult.object = { activadas: n };
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
/**
|
||||
* `nombres`/`apellidos` a mayúscula inicial por palabra
|
||||
* (`DIEGO LLUSCO` → `Diego Llusco`). Solo actualiza las filas que cambian.
|
||||
*/
|
||||
async normalizarNombres(): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
const filas = await this.personaRepo.find({
|
||||
select: { idPersona: true, nombres: true, apellidos: true },
|
||||
});
|
||||
|
||||
let cambios = 0;
|
||||
for (const p of filas) {
|
||||
const nombres = this.capitalizarPalabras(p.nombres ?? '');
|
||||
const apellidos = this.capitalizarPalabras(p.apellidos ?? '');
|
||||
if (nombres === p.nombres && apellidos === p.apellidos) continue;
|
||||
await this.personaRepo.update(
|
||||
{ idPersona: p.idPersona },
|
||||
{ nombres, apellidos },
|
||||
);
|
||||
cambios++;
|
||||
}
|
||||
|
||||
serviceResult.boolean = true;
|
||||
serviceResult.message =
|
||||
cambios === 0
|
||||
? 'Todos los nombres ya tienen mayúscula inicial.'
|
||||
: `${cambios} persona(s) con nombres/apellidos normalizados.`;
|
||||
serviceResult.number = cambios;
|
||||
serviceResult.object = { normalizadas: cambios };
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
/// Mayúscula inicial de cada palabra; el resto en minúscula.
|
||||
private capitalizarPalabras(texto: string): string {
|
||||
return texto
|
||||
.split(/(\s+)/)
|
||||
.map((parte) => {
|
||||
if (/^\s+$/.test(parte) || parte === '') return parte;
|
||||
const min = parte.toLowerCase();
|
||||
const primera = min.match(/\p{L}/u);
|
||||
if (!primera) return min;
|
||||
const i = min.search(/\p{L}/u);
|
||||
return min.slice(0, i) + min[i].toUpperCase() + min.slice(i + 1);
|
||||
})
|
||||
.join('');
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ import { Module } from '@nestjs/common';
|
|||
import { TypeOrmModule } from '@nestjs/typeorm';
|
||||
import { Reemplazo } from './entities/reemplazo.entity.js';
|
||||
import { Servicio } from '../servicio/entities/servicio.entity.js';
|
||||
import { ServicioEquipo } from '../servicio-equipo/entities/servicio-equipo.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';
|
||||
|
|
@ -11,7 +12,14 @@ import { ReemplazoController } from './reemplazo.controller.js';
|
|||
|
||||
@Module({
|
||||
imports: [
|
||||
TypeOrmModule.forFeature([Reemplazo, Servicio, Asistencia, EquipoPersona, Persona]),
|
||||
TypeOrmModule.forFeature([
|
||||
Reemplazo,
|
||||
Servicio,
|
||||
ServicioEquipo,
|
||||
Asistencia,
|
||||
EquipoPersona,
|
||||
Persona,
|
||||
]),
|
||||
RealtimeModule,
|
||||
],
|
||||
exports: [ReemplazoService, TypeOrmModule],
|
||||
|
|
|
|||
|
|
@ -4,14 +4,15 @@ import { Repository } from 'typeorm';
|
|||
import { EventsService } from '../../common/services/events.service.js';
|
||||
import { Reemplazo } from './entities/reemplazo.entity.js';
|
||||
import { Servicio } from '../servicio/entities/servicio.entity.js';
|
||||
import { ServicioEquipo } from '../servicio-equipo/entities/servicio-equipo.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 { AceptarReemplazoDto, ReemplazoDto } from './dto/reemplazo.dto.js';
|
||||
import {
|
||||
AceptarReemplazoDto,
|
||||
ReemplazoDto,
|
||||
} from './dto/reemplazo.dto.js';
|
||||
import { defaultServiceResult, ServiceResult } from '../../common/interfaces/service.result.js';
|
||||
defaultServiceResult,
|
||||
ServiceResult,
|
||||
} from '../../common/interfaces/service.result.js';
|
||||
import { WhereCondition } from '../../common/types/query-builder.types.js';
|
||||
import {
|
||||
EstadoAsistencia,
|
||||
|
|
@ -23,7 +24,11 @@ import {
|
|||
import { TipoAsistencia } from '../../common/enums/tipos.enum.js';
|
||||
import { Rol } from '../../common/enums/rol.enum.js';
|
||||
import { REMPLAZO_FIND_WHITELIST } from './reemplazo.constants.js';
|
||||
import { AuthUser, isDeveloper, isSuperAdmin } from '../../common/utils/auth-user.js';
|
||||
import {
|
||||
AuthUser,
|
||||
isDeveloper,
|
||||
isSuperAdmin,
|
||||
} from '../../common/utils/auth-user.js';
|
||||
|
||||
@Injectable()
|
||||
export class ReemplazoService {
|
||||
|
|
@ -34,6 +39,8 @@ export class ReemplazoService {
|
|||
private reemplazoRepository: Repository<Reemplazo>,
|
||||
@InjectRepository(Servicio)
|
||||
private servicioRepository: Repository<Servicio>,
|
||||
@InjectRepository(ServicioEquipo)
|
||||
private servicioEquipoRepository: Repository<ServicioEquipo>,
|
||||
@InjectRepository(Asistencia)
|
||||
private asistenciaRepository: Repository<Asistencia>,
|
||||
@InjectRepository(EquipoPersona)
|
||||
|
|
@ -59,10 +66,6 @@ export class ReemplazoService {
|
|||
serviceResult.message = 'No existe el servicio.';
|
||||
return serviceResult;
|
||||
}
|
||||
if (servicio.estado !== EstadoServicio.Publicado) {
|
||||
serviceResult.message = 'Solo se puede solicitar reemplazo en servicio Publicado.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
const membresia = await this.equipoPersonaRepository.findOneBy({
|
||||
idPersona: idPersonaTitular,
|
||||
|
|
@ -73,12 +76,28 @@ export class ReemplazoService {
|
|||
return serviceResult;
|
||||
}
|
||||
|
||||
// El estado vivo es el del EQUIPO del titular en este servicio.
|
||||
const se = await this.servicioEquipoRepository.findOneBy({
|
||||
idServicio: dto.idServicio,
|
||||
idEquipo: membresia.idEquipo,
|
||||
});
|
||||
const estadoEquipo = se?.estado;
|
||||
const estadoVivo = se
|
||||
? estadoEquipo
|
||||
: ((servicio.estado as EstadoServicio | null) ?? null);
|
||||
if (estadoVivo !== EstadoServicio.Publicado) {
|
||||
serviceResult.message =
|
||||
'Solo se puede solicitar reemplazo cuando el equipo está Publicado.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
const asistencia = await this.asistenciaRepository.findOneBy({
|
||||
idServicio: dto.idServicio,
|
||||
idPersona: idPersonaTitular,
|
||||
});
|
||||
if (!asistencia) {
|
||||
serviceResult.message = 'No existe fila de asistencia para este titular en el servicio.';
|
||||
serviceResult.message =
|
||||
'No existe fila de asistencia para este titular en el servicio.';
|
||||
return serviceResult;
|
||||
}
|
||||
if (asistencia.tipo !== TipoAsistencia.Titular) {
|
||||
|
|
@ -96,7 +115,8 @@ export class ReemplazoService {
|
|||
estado: EstadoConvocatoria.Abierto,
|
||||
});
|
||||
if (abierto) {
|
||||
serviceResult.message = 'Ya existe un reemplazo Abierto para este titular.';
|
||||
serviceResult.message =
|
||||
'Ya existe un reemplazo Abierto para este titular.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
|
|
@ -106,7 +126,8 @@ export class ReemplazoService {
|
|||
estado: EstadoConvocatoria.Cubierto,
|
||||
});
|
||||
if (cubierto) {
|
||||
serviceResult.message = 'Ya existe un reemplazo Cubierto para este titular.';
|
||||
serviceResult.message =
|
||||
'Ya existe un reemplazo Cubierto para este titular.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
|
|
@ -130,7 +151,7 @@ export class ReemplazoService {
|
|||
const elegibles = await this.personaRepository
|
||||
.createQueryBuilder('p')
|
||||
.where('p.estado = :e', { e: EstadoGeneral.Activo })
|
||||
.andWhere("p.rol != :admin", { admin: Rol.Admin })
|
||||
.andWhere('p.rol != :admin', { admin: Rol.Admin })
|
||||
.andWhere('p."idPersona" != :titular', { titular: idPersonaTitular })
|
||||
.getMany();
|
||||
const ids = elegibles.map((p) => p.idPersona);
|
||||
|
|
@ -142,7 +163,9 @@ export class ReemplazoService {
|
|||
data: { idReemplazo: result.idReemplazo, idServicio: dto.idServicio },
|
||||
});
|
||||
} catch (error) {
|
||||
this.logger.warn(`No se pudo emitir evento reemplazo: ${error.message}`);
|
||||
this.logger.warn(
|
||||
`No se pudo emitir evento reemplazo: ${error.message}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -283,7 +306,11 @@ export class ReemplazoService {
|
|||
/**
|
||||
* Aceptación atómica + cambio de tipo de asistencia a 'Reemplazo'.
|
||||
*/
|
||||
async aceptar(idReemplazo: string, dto: AceptarReemplazoDto, user: AuthUser): Promise<ServiceResult> {
|
||||
async aceptar(
|
||||
idReemplazo: string,
|
||||
dto: AceptarReemplazoDto,
|
||||
user: AuthUser,
|
||||
): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
|
||||
const reemplazo = await this.reemplazoRepository.findOneBy({ idReemplazo });
|
||||
|
|
@ -298,7 +325,9 @@ export class ReemplazoService {
|
|||
}
|
||||
|
||||
const solicitante = dto.idPersonaReemplazo ?? user.idPersona;
|
||||
const persona = await this.personaRepository.findOneBy({ idPersona: solicitante });
|
||||
const persona = await this.personaRepository.findOneBy({
|
||||
idPersona: solicitante,
|
||||
});
|
||||
if (!persona || persona.estado !== EstadoGeneral.Activo) {
|
||||
serviceResult.message = 'El reemplazante no existe o no está activo.';
|
||||
return serviceResult;
|
||||
|
|
@ -369,7 +398,9 @@ export class ReemplazoService {
|
|||
idReemplazo,
|
||||
})
|
||||
.where('"idServicio" = :idServicio', { idServicio: reemplazo.idServicio })
|
||||
.andWhere('"idPersona" = :idTitular', { idTitular: reemplazo.idPersonaTitular })
|
||||
.andWhere('"idPersona" = :idTitular', {
|
||||
idTitular: reemplazo.idPersonaTitular,
|
||||
})
|
||||
.execute();
|
||||
|
||||
serviceResult.boolean = true;
|
||||
|
|
@ -386,7 +417,9 @@ export class ReemplazoService {
|
|||
data: { idReemplazo },
|
||||
});
|
||||
} catch (error) {
|
||||
this.logger.warn(`No se pudo emitir evento reemplazo cubierto: ${error.message}`);
|
||||
this.logger.warn(
|
||||
`No se pudo emitir evento reemplazo cubierto: ${error.message}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -416,17 +449,23 @@ export class ReemplazoService {
|
|||
const servicio = await this.servicioRepository.findOneBy({
|
||||
idServicio: reemplazo.idServicio,
|
||||
});
|
||||
const se = await this.servicioEquipoRepository.findOneBy({
|
||||
idServicio: reemplazo.idServicio,
|
||||
idEquipo: reemplazo.idEquipo,
|
||||
});
|
||||
const estadoVivo = se
|
||||
? se.estado
|
||||
: ((servicio?.estado as EstadoServicio | null) ?? null);
|
||||
const servicioIniciado =
|
||||
servicio?.estado === EstadoServicio.EnCurso ||
|
||||
servicio?.estado === EstadoServicio.Finalizado;
|
||||
estadoVivo === EstadoServicio.EnCurso ||
|
||||
estadoVivo === EstadoServicio.Finalizado;
|
||||
|
||||
const esTitular = user.idPersona === reemplazo.idPersonaTitular;
|
||||
const puedeAdmin = isDeveloper(user) || isSuperAdmin(user);
|
||||
|
||||
if (esTitular && !puedeAdmin) {
|
||||
if (servicioIniciado) {
|
||||
serviceResult.message =
|
||||
'No puede cancelar: el servicio ya inició.';
|
||||
serviceResult.message = 'No puede cancelar: el servicio ya inició.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
|
|
@ -442,8 +481,12 @@ export class ReemplazoService {
|
|||
idReemplazo: null,
|
||||
tipo: TipoAsistencia.Titular,
|
||||
})
|
||||
.where('"idServicio" = :idServicio', { idServicio: reemplazo.idServicio })
|
||||
.andWhere('"idPersona" = :idTitular', { idTitular: reemplazo.idPersonaTitular })
|
||||
.where('"idServicio" = :idServicio', {
|
||||
idServicio: reemplazo.idServicio,
|
||||
})
|
||||
.andWhere('"idPersona" = :idTitular', {
|
||||
idTitular: reemplazo.idPersonaTitular,
|
||||
})
|
||||
.execute();
|
||||
});
|
||||
|
||||
|
|
@ -475,8 +518,12 @@ export class ReemplazoService {
|
|||
}
|
||||
|
||||
private async puedeVer(user: AuthUser, r: Reemplazo): Promise<boolean> {
|
||||
if (isDeveloper(user) || isSuperAdmin(user) || user.rol === Rol.Admin) return true;
|
||||
if (r.idPersonaTitular === user.idPersona || r.idPersonaReemplazo === user.idPersona) {
|
||||
if (isDeveloper(user) || isSuperAdmin(user) || user.rol === Rol.Admin)
|
||||
return true;
|
||||
if (
|
||||
r.idPersonaTitular === user.idPersona ||
|
||||
r.idPersonaReemplazo === user.idPersona
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
if (user.rol === Rol.Lider || user.rol === Rol.Estaca) {
|
||||
|
|
|
|||
|
|
@ -38,6 +38,14 @@ import { TipoReporte } from './dto/reporte.dto.js';
|
|||
/** Fila cruda de los reportes (JSON para el front, base de las tablas PDF). */
|
||||
type Fila = Record<string, unknown>;
|
||||
|
||||
/**
|
||||
* Subrutina de «Inhabilitado» (servidores sin ingreso en 3 meses al
|
||||
* generar el reporte de asistencia) — **deshabilitada por ahora**
|
||||
* (decisión del usuario 2026-10-27: el reporte ya no marca a nadie).
|
||||
* Para reactivarla, poner en `true`.
|
||||
*/
|
||||
const EVALUAR_INHABILITADOS = false;
|
||||
|
||||
interface Col {
|
||||
header: string;
|
||||
width: number;
|
||||
|
|
@ -63,12 +71,33 @@ interface DatosReporte {
|
|||
control?: EncabezadoControl;
|
||||
}
|
||||
|
||||
/** Estados de servicio "realizados" (para los 4 reportes de rango). */
|
||||
const ESTADOS_REALIZADO = [
|
||||
EstadoServicio.Publicado,
|
||||
EstadoServicio.EnCurso,
|
||||
EstadoServicio.Finalizado,
|
||||
];
|
||||
|
||||
/**
|
||||
* Condición SQL: el servicio "está" en uno de ESTADOS_REALIZADO si algún
|
||||
* equipo lo está (multi-equipo) o, sin equipos, `servicio.estado`.
|
||||
* `$1` = array de estados (`{Publicado,EnCurso,…}`).
|
||||
*/
|
||||
const SQL_ESTADO_REALIZADO = `(
|
||||
EXISTS (
|
||||
SELECT 1 FROM servicio_equipo se
|
||||
WHERE se."idServicio" = s."idServicio"
|
||||
AND se.estado = ANY($1::text[])
|
||||
AND se.estado <> '${EstadoServicio.Eliminado}'
|
||||
) OR (
|
||||
NOT EXISTS (
|
||||
SELECT 1 FROM servicio_equipo se2
|
||||
WHERE se2."idServicio" = s."idServicio"
|
||||
)
|
||||
AND s.estado = ANY($1::text[])
|
||||
)
|
||||
)`;
|
||||
|
||||
const MESES_CORTOS = [
|
||||
'Ene.',
|
||||
'Feb.',
|
||||
|
|
@ -149,7 +178,7 @@ export class ReportesService {
|
|||
to_char(fecha, 'YYYY-MM-DD') AS fecha,
|
||||
estado
|
||||
FROM servicio
|
||||
WHERE "idServicio" = $1 AND estado <> $2`,
|
||||
WHERE "idServicio" = $1 AND estado IS DISTINCT FROM $2`,
|
||||
[idServicio, EstadoServicio.Eliminado],
|
||||
);
|
||||
if (!servicioRows.length) {
|
||||
|
|
@ -158,30 +187,40 @@ export class ReportesService {
|
|||
|
||||
// Convocados con su nombre (para el selector de equipo del front).
|
||||
const convocados: Fila[] = await manager.query(
|
||||
`SELECT se."idEquipo", e."nombreEquipo"
|
||||
`SELECT se."idEquipo", e."nombreEquipo", se.estado
|
||||
FROM servicio_equipo se
|
||||
JOIN equipo e ON e."idEquipo" = se."idEquipo"
|
||||
WHERE se."idServicio" = $1
|
||||
AND se.estado <> $2
|
||||
ORDER BY e."nombreEquipo"`,
|
||||
[idServicio],
|
||||
[idServicio, EstadoServicio.Eliminado],
|
||||
);
|
||||
|
||||
// Scoping Líder: solo sus equipos (membresía Activa ∩ convocados).
|
||||
let equipos: string[] | null = await this.equiposScope(user);
|
||||
if (equipos !== null) {
|
||||
const set = new Set(equipos);
|
||||
equipos = convocados
|
||||
.map((c) => c.idEquipo as string)
|
||||
.filter((id) => set.has(id));
|
||||
if (!equipos.length) {
|
||||
// Scoping 10.1: la membresía ACTIVA en un equipo convocado manda
|
||||
// primero (aunque el usuario sea Dev/SuperAdmin — así un SuperAdmin
|
||||
// que además es Líder no se come los otros equipos); Dev/Super sin
|
||||
// membresía en el servicio → vista global.
|
||||
const esGlobal = isDeveloper(user) || isSuperAdmin(user);
|
||||
const membresias: { idEquipo: string }[] = await manager.query(
|
||||
`SELECT "idEquipo" FROM equipo_persona
|
||||
WHERE "idPersona" = $1 AND estado = $2`,
|
||||
[user?.idPersona, EstadoMiembro.Activo],
|
||||
);
|
||||
const setMembresias = new Set(membresias.map((m) => m.idEquipo));
|
||||
let equipos: string[] | null = convocados
|
||||
.map((c) => c.idEquipo as string)
|
||||
.filter((id) => setMembresias.has(id));
|
||||
if (!equipos.length) {
|
||||
if (!esGlobal) {
|
||||
throw new ForbiddenException(
|
||||
'Solo el líder de un equipo convocado del servicio puede ver el reporte.',
|
||||
);
|
||||
}
|
||||
equipos = null;
|
||||
}
|
||||
|
||||
// Selector de equipo (un equipo o "Todos"): si viene idEquipo debe ser
|
||||
// uno de los convocados (y del scoping del líder).
|
||||
// convocado; fuera del alcance del líder solo Dev/Super pueden forzarlo.
|
||||
const convocadoSet = new Set(convocados.map((c) => c.idEquipo as string));
|
||||
if (idEquipo) {
|
||||
if (!convocadoSet.has(idEquipo)) {
|
||||
|
|
@ -189,11 +228,27 @@ export class ReportesService {
|
|||
'El equipo no está convocado en el servicio.',
|
||||
);
|
||||
}
|
||||
if (equipos !== null && !equipos.includes(idEquipo)) {
|
||||
if (equipos !== null && !esGlobal && !equipos.includes(idEquipo)) {
|
||||
throw new ForbiddenException('No podés ver reportes de ese equipo.');
|
||||
}
|
||||
}
|
||||
|
||||
// Gate: el alcance por membresía (Líder, con cualquier autorización)
|
||||
// solo genera el reporte si SUS equipos están Finalizado. Dev/Super
|
||||
// global o forzando un idEquipo concreto: sin exigir cierre.
|
||||
const gateCierre = equipos !== null && !(esGlobal && idEquipo);
|
||||
if (equipos !== null && gateCierre) {
|
||||
const estadosPropios = equipos.map(
|
||||
(id) =>
|
||||
(convocados.find((c) => c.idEquipo === id)?.estado as string) ?? '',
|
||||
);
|
||||
if (estadosPropios.some((e) => e !== EstadoServicio.Finalizado)) {
|
||||
throw new BadRequestException(
|
||||
'El reporte del equipo está disponible solo cuando el equipo está Finalizado.',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Título del reporte: un equipo → "Equipo X - Reporte"; Todos →
|
||||
// "Ministerio Ser - Reporte".
|
||||
const nombreEquipoSel = idEquipo
|
||||
|
|
@ -245,14 +300,23 @@ export class ReportesService {
|
|||
JOIN persona p ON p."idPersona" = a."idPersona"
|
||||
JOIN equipo e ON e."idEquipo" = a."idEquipo"
|
||||
WHERE ${whereFilas}
|
||||
ORDER BY e."nombreEquipo", p.apellidos, p.nombres`,
|
||||
ORDER BY a."fecIngreso" ASC NULLS LAST,
|
||||
e."nombreEquipo", p.apellidos, p.nombres`,
|
||||
paramsFilas,
|
||||
);
|
||||
|
||||
// Subrutina de la tanda: servidores activos sin ingreso en 3 meses
|
||||
// calendario → Inhabilitado (solo al generar este reporte). No es un
|
||||
// bloqueo: la persona sigue pudiendo entrar y marcar (rehabilita sola).
|
||||
const inhabilitados = await this.evaluarInhabilitados();
|
||||
// Subrutina de Inhabilitado (3 meses sin ingreso → marca a la persona,
|
||||
// acotada a los equipos de ESTE reporte): **apagada por ahora** con
|
||||
// EVALUAR_INHABILITADOS (decisión 2026-10-27). La persona ya marcada
|
||||
// se reactiva desde Más → Mantenimiento → Activar personas.
|
||||
const idsParaInhabilitar = idEquipo
|
||||
? [idEquipo]
|
||||
: equipos === null
|
||||
? convocados.map((c) => c.idEquipo as string)
|
||||
: equipos;
|
||||
const inhabilitados = EVALUAR_INHABILITADOS
|
||||
? await this.evaluarInhabilitados(idsParaInhabilitar)
|
||||
: [];
|
||||
|
||||
// `equiposVisibles` acota el selector del front al scoping del líder.
|
||||
const equiposVisibles =
|
||||
|
|
@ -286,7 +350,7 @@ export class ReportesService {
|
|||
const scope = await this.equiposScope(user);
|
||||
|
||||
const filtros: string[] = [
|
||||
's.estado = ANY($1)',
|
||||
SQL_ESTADO_REALIZADO,
|
||||
's.fecha >= $2::date',
|
||||
's.fecha <= $3::date',
|
||||
];
|
||||
|
|
@ -348,7 +412,7 @@ export class ReportesService {
|
|||
const scope = await this.equiposScope(user);
|
||||
|
||||
const filtros: string[] = [
|
||||
's.estado = ANY($1)',
|
||||
SQL_ESTADO_REALIZADO,
|
||||
's.fecha >= $2::date',
|
||||
's.fecha <= $3::date',
|
||||
];
|
||||
|
|
@ -396,7 +460,7 @@ export class ReportesService {
|
|||
|
||||
const filtros: string[] = [
|
||||
`a.estado IN ('Falta','Permiso')`,
|
||||
's.estado = ANY($1)',
|
||||
SQL_ESTADO_REALIZADO,
|
||||
's.fecha >= $2::date',
|
||||
's.fecha <= $3::date',
|
||||
];
|
||||
|
|
@ -447,7 +511,7 @@ export class ReportesService {
|
|||
const scope = await this.equiposScope(user);
|
||||
|
||||
const filtros: string[] = [
|
||||
's.estado = ANY($1)',
|
||||
SQL_ESTADO_REALIZADO,
|
||||
's.fecha >= $2::date',
|
||||
's.fecha <= $3::date',
|
||||
];
|
||||
|
|
@ -484,11 +548,13 @@ export class ReportesService {
|
|||
// ------------------------------------------------------- inhabilitados
|
||||
|
||||
/**
|
||||
* Servidores con membresía activa, `estado = Activo` y **cero ingresos**
|
||||
* (Presente/Atrasado con `fecIngreso`) en los últimos 3 meses calendario
|
||||
* → pasan a `Inhabilitado`. Devuelve los marcados en esta corrida.
|
||||
* Servidores con membresía activa **en `idsEquipo`** (los equipos del
|
||||
* reporte), `estado = Activo` y **cero ingresos** (Presente/Atrasado con
|
||||
* `fecIngreso`) en los últimos 3 meses calendario → `Inhabilitado`.
|
||||
* Devuelve los marcados en esta corrida. `idsEquipo` vacío = sin marcados.
|
||||
*/
|
||||
private async evaluarInhabilitados(): Promise<Fila[]> {
|
||||
private async evaluarInhabilitados(idsEquipo: string[]): Promise<Fila[]> {
|
||||
if (!idsEquipo.length) return [];
|
||||
const manager = this.personaRepository.manager;
|
||||
const candidatos: Fila[] = await manager.query(
|
||||
`SELECT p."idPersona",
|
||||
|
|
@ -497,11 +563,12 @@ export class ReportesService {
|
|||
FROM persona p
|
||||
WHERE p.rol = $1
|
||||
AND p.estado = $2
|
||||
AND p.autorizacion = $6
|
||||
AND p.autorizacion = $7
|
||||
AND EXISTS (
|
||||
SELECT 1 FROM equipo_persona ep
|
||||
WHERE ep."idPersona" = p."idPersona"
|
||||
AND ep.estado = $3
|
||||
AND ep."idEquipo" = ANY($6::uuid[])
|
||||
)
|
||||
AND NOT EXISTS (
|
||||
SELECT 1 FROM asistencia a
|
||||
|
|
@ -516,6 +583,7 @@ export class ReportesService {
|
|||
EstadoMiembro.Activo,
|
||||
EstadoAsistencia.Presente,
|
||||
EstadoAsistencia.Atrasado,
|
||||
`{${idsEquipo.join(',')}}`,
|
||||
Autorizacion.Usuario,
|
||||
],
|
||||
);
|
||||
|
|
@ -672,8 +740,9 @@ export class ReportesService {
|
|||
return serviceResult;
|
||||
}
|
||||
|
||||
// El método de datos por servicio se separa para poder reutilizarlo en el
|
||||
// PDF con su side-effect de inhabilitados incluido.
|
||||
// El método de datos por servicio se separa para poder reutilizarlo en
|
||||
// el PDF (la subrutina de inhabilitados está apagada: ver
|
||||
// EVALUAR_INHABILITADOS).
|
||||
private async datosAsistenciaServicio(
|
||||
idServicio: string | undefined,
|
||||
user: AuthUser | null,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
|
||||
import { EstadoServicio } from '../../../common/enums/estados.enum.js';
|
||||
|
||||
@Entity('servicio_equipo')
|
||||
export class ServicioEquipo {
|
||||
|
|
@ -13,4 +14,21 @@ export class ServicioEquipo {
|
|||
|
||||
@Column({ type: 'uuid' })
|
||||
asignadoPor: string;
|
||||
|
||||
/**
|
||||
* Ciclo de vida de ESTE equipo en el servicio (multi-equipo: cada líder
|
||||
* maneja el suyo). Dev/SuperAdmin pueden mover cualquier fila.
|
||||
*/
|
||||
@Column({
|
||||
type: 'varchar',
|
||||
default: EstadoServicio.Programado,
|
||||
})
|
||||
estado: EstadoServicio;
|
||||
|
||||
/**
|
||||
* PIN de 6 dígitos del equipo para marcar (PIN/QR). Se genera al publicar
|
||||
* esta fila (`estado = Publicado`).
|
||||
*/
|
||||
@Column({ type: 'varchar', nullable: true })
|
||||
pinMarcado?: string | null;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1 +1,6 @@
|
|||
export const SERVICIO_EQUIPO_FIND_WHITELIST = ['idServicio', 'idEquipo', 'asignadoPor'];
|
||||
export const SERVICIO_EQUIPO_FIND_WHITELIST = [
|
||||
'idServicio',
|
||||
'idEquipo',
|
||||
'asignadoPor',
|
||||
'estado',
|
||||
];
|
||||
|
|
|
|||
|
|
@ -4,7 +4,10 @@ import { Repository } from 'typeorm';
|
|||
import { ServicioEquipo } from './entities/servicio-equipo.entity.js';
|
||||
import { Servicio } from '../servicio/entities/servicio.entity.js';
|
||||
import { ServicioEquipoDto } from './dto/servicio-equipo.dto.js';
|
||||
import { defaultServiceResult, ServiceResult } from '../../common/interfaces/service.result.js';
|
||||
import {
|
||||
defaultServiceResult,
|
||||
ServiceResult,
|
||||
} from '../../common/interfaces/service.result.js';
|
||||
import { WhereCondition } from '../../common/types/query-builder.types.js';
|
||||
import { EstadoServicio } from '../../common/enums/estados.enum.js';
|
||||
import { SERVICIO_EQUIPO_FIND_WHITELIST } from './servicio-equipo.constants.js';
|
||||
|
|
@ -28,13 +31,18 @@ export class ServicioEquipoService {
|
|||
serviceResult.message = 'No existe el servicio.';
|
||||
return serviceResult;
|
||||
}
|
||||
if (servicio.estado !== EstadoServicio.Programado) {
|
||||
if (servicio.estado === EstadoServicio.Eliminado) {
|
||||
serviceResult.message =
|
||||
'Solo se pueden convocar equipos a servicios en estado Programado.';
|
||||
'No se pueden convocar equipos a un servicio eliminado.';
|
||||
return serviceResult;
|
||||
}
|
||||
// La fila nace en Programado; el resto del ciclo de vida es por equipo
|
||||
// (se puede convocar aunque otros equipos ya estén Publicados).
|
||||
|
||||
const entity = this.servicioEquipoRepository.create(servicioEquipoDto);
|
||||
const entity = this.servicioEquipoRepository.create({
|
||||
...servicioEquipoDto,
|
||||
estado: EstadoServicio.Programado,
|
||||
});
|
||||
const result = await this.servicioEquipoRepository.save(entity);
|
||||
|
||||
serviceResult.boolean = true;
|
||||
|
|
@ -48,7 +56,9 @@ export class ServicioEquipoService {
|
|||
async findOne(idServicioEquipo: string): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
|
||||
const result = await this.servicioEquipoRepository.findOneBy({ idServicioEquipo });
|
||||
const result = await this.servicioEquipoRepository.findOneBy({
|
||||
idServicioEquipo,
|
||||
});
|
||||
|
||||
if (result) {
|
||||
serviceResult.boolean = true;
|
||||
|
|
@ -72,7 +82,8 @@ export class ServicioEquipoService {
|
|||
const serviceResult = defaultServiceResult();
|
||||
|
||||
try {
|
||||
let query = this.servicioEquipoRepository.createQueryBuilder('servicioEquipo');
|
||||
let query =
|
||||
this.servicioEquipoRepository.createQueryBuilder('servicioEquipo');
|
||||
|
||||
whereConditions.forEach((condition, index) => {
|
||||
const { attribute, value, operator = '=' } = condition;
|
||||
|
|
@ -97,7 +108,10 @@ export class ServicioEquipoService {
|
|||
throw new Error(`Atributo de orden no permitido: ${orderByAttribute}`);
|
||||
}
|
||||
|
||||
query = query.orderBy(`servicioEquipo.${orderByAttribute}`, orderByDirection);
|
||||
query = query.orderBy(
|
||||
`servicioEquipo.${orderByAttribute}`,
|
||||
orderByDirection,
|
||||
);
|
||||
|
||||
const totalRegistros = await query.getCount();
|
||||
const skip = (offset - 1) * limit;
|
||||
|
|
|
|||
|
|
@ -5,7 +5,10 @@ import { ServicioTurno } from './entities/servicio-turno.entity.js';
|
|||
import { Servicio } from '../servicio/entities/servicio.entity.js';
|
||||
import { ServicioTurnoDto } from './dto/servicio-turno.dto.js';
|
||||
import { UpdateServicioTurnoDto } from './dto/update-servicio-turno.dto.js';
|
||||
import { defaultServiceResult, ServiceResult } from '../../common/interfaces/service.result.js';
|
||||
import {
|
||||
defaultServiceResult,
|
||||
ServiceResult,
|
||||
} from '../../common/interfaces/service.result.js';
|
||||
import { WhereCondition } from '../../common/types/query-builder.types.js';
|
||||
import { EstadoServicio } from '../../common/enums/estados.enum.js';
|
||||
import { SERVICIO_TURNO_FIND_WHITELIST } from './servicio-turno.constants.js';
|
||||
|
|
@ -25,15 +28,14 @@ export class ServicioTurnoService {
|
|||
const servicio = await this.servicioRepository.findOneBy({
|
||||
idServicio: servicioTurnoDto.idServicio,
|
||||
});
|
||||
if (!servicio) {
|
||||
serviceResult.message = 'No existe el servicio.';
|
||||
return serviceResult;
|
||||
}
|
||||
if (servicio.estado !== EstadoServicio.Programado) {
|
||||
serviceResult.message =
|
||||
'Solo se pueden asignar turnos a servicios en estado Programado.';
|
||||
if (!servicio || servicio.estado === EstadoServicio.Eliminado) {
|
||||
serviceResult.message = servicio
|
||||
? 'El servicio está eliminado.'
|
||||
: 'No existe el servicio.';
|
||||
return serviceResult;
|
||||
}
|
||||
// Turnos compartidos del servicio: SuperAdmin puede programarlos aunque
|
||||
// algún equipo ya no esté en Programado (decisión 2026-10-26).
|
||||
|
||||
const entity = this.servicioTurnoRepository.create(servicioTurnoDto);
|
||||
const result = await this.servicioTurnoRepository.save(entity);
|
||||
|
|
@ -49,7 +51,9 @@ export class ServicioTurnoService {
|
|||
async findOne(idServicioTurno: string): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
|
||||
const result = await this.servicioTurnoRepository.findOneBy({ idServicioTurno });
|
||||
const result = await this.servicioTurnoRepository.findOneBy({
|
||||
idServicioTurno,
|
||||
});
|
||||
|
||||
if (result) {
|
||||
serviceResult.boolean = true;
|
||||
|
|
@ -73,7 +77,8 @@ export class ServicioTurnoService {
|
|||
const serviceResult = defaultServiceResult();
|
||||
|
||||
try {
|
||||
let query = this.servicioTurnoRepository.createQueryBuilder('servicioTurno');
|
||||
let query =
|
||||
this.servicioTurnoRepository.createQueryBuilder('servicioTurno');
|
||||
|
||||
whereConditions.forEach((condition, index) => {
|
||||
const { attribute, value, operator = '=' } = condition;
|
||||
|
|
@ -98,7 +103,10 @@ export class ServicioTurnoService {
|
|||
throw new Error(`Atributo de orden no permitido: ${orderByAttribute}`);
|
||||
}
|
||||
|
||||
query = query.orderBy(`servicioTurno.${orderByAttribute}`, orderByDirection);
|
||||
query = query.orderBy(
|
||||
`servicioTurno.${orderByAttribute}`,
|
||||
orderByDirection,
|
||||
);
|
||||
|
||||
const totalRegistros = await query.getCount();
|
||||
const skip = (offset - 1) * limit;
|
||||
|
|
|
|||
|
|
@ -1,16 +1,26 @@
|
|||
import { ApiProperty } from '@nestjs/swagger';
|
||||
import { IsEnum, IsNotEmpty } from 'class-validator';
|
||||
import { IsEnum, IsNotEmpty, IsOptional, IsString } from 'class-validator';
|
||||
import { EstadoServicio } from '../../../common/enums/estados.enum.js';
|
||||
|
||||
export class CambiarEstadoServicioDto {
|
||||
@ApiProperty({
|
||||
enum: EstadoServicio,
|
||||
description:
|
||||
'Matriz normal: Programado→Publicado/Cancelado; Publicado→EnCurso/Cancelado; ' +
|
||||
'EnCurso→Finalizado/Cancelado. SuperAdmin/Developer pueden elegir cualquier ' +
|
||||
'estado salvo el actual (corrección de errores).',
|
||||
'Multi-equipo: estado de servicio_equipo (por defecto todos los ' +
|
||||
'equipos del alcance del usuario; `idEquipo` acota a uno). Sin ' +
|
||||
'equipos: máquina clásica del servicio. Publicar solo SuperAdmin/Dev; ' +
|
||||
'Líder solo EnCurso/Finalizado de sus equipos.',
|
||||
})
|
||||
@IsEnum(EstadoServicio)
|
||||
@IsNotEmpty()
|
||||
estado: EstadoServicio;
|
||||
|
||||
@ApiProperty({
|
||||
required: false,
|
||||
description:
|
||||
'Id de equipo convocado; si falta, aplica al alcance del usuario.',
|
||||
})
|
||||
@IsString()
|
||||
@IsOptional()
|
||||
idEquipo?: string;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,16 +21,12 @@ export class Servicio {
|
|||
@Column({ type: 'double precision', nullable: true })
|
||||
lng?: number | null;
|
||||
|
||||
@Column({
|
||||
type: 'varchar',
|
||||
default: EstadoServicio.Programado,
|
||||
})
|
||||
estado: EstadoServicio;
|
||||
|
||||
/**
|
||||
* PIN de 6 dígitos para marcar asistencia (PIN tecleado o escaneado en QR).
|
||||
* Se genera al publicar el servicio; el líder lo ve en el detalle.
|
||||
* Solo se usa cuando el servicio NO tiene equipos convocados (extraordinario
|
||||
* con turnos + apoyos). Si hay filas en `servicio_equipo`, el ciclo de vida
|
||||
* (y el PIN) viven en cada fila de equipo; aquí queda `null`.
|
||||
* `Eliminado` sigue siendo el borrado lógico del servicio completo.
|
||||
*/
|
||||
@Column({ type: 'varchar', nullable: true })
|
||||
pinMarcado?: string | null;
|
||||
estado?: EstadoServicio | null;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ export const SERVICIO_FIND_WHITELIST = [
|
|||
'estado',
|
||||
];
|
||||
|
||||
/** Matriz de transiciones de estado del servicio */
|
||||
/** Matriz de transiciones de estado del servicio (solo sin equipos). */
|
||||
export const SERVICIO_TRANSICIONES: Record<string, string[]> = {
|
||||
Programado: ['Publicado', 'Cancelado'],
|
||||
Publicado: ['EnCurso', 'Cancelado'],
|
||||
|
|
@ -13,3 +13,26 @@ export const SERVICIO_TRANSICIONES: Record<string, string[]> = {
|
|||
Finalizado: [],
|
||||
Cancelado: [],
|
||||
};
|
||||
|
||||
/**
|
||||
* Matriz de transiciones de `servicio_equipo.estado` para Dev/SuperAdmin
|
||||
* (relajada: cualquier destino salvo el actual, incl. Eliminado).
|
||||
*/
|
||||
export const SERVICIO_EQUIPO_TRANSICIONES_SUPER: Record<string, string[]> = {
|
||||
Programado: ['Publicado', 'Cancelado', 'Eliminado'],
|
||||
Publicado: ['EnCurso', 'Finalizado', 'Cancelado', 'Eliminado'],
|
||||
EnCurso: ['Finalizado', 'Cancelado', 'Eliminado'],
|
||||
// Reabrir solo Dev/Super para que un líder pueda volver a cerrar.
|
||||
Finalizado: ['EnCurso', 'Cancelado', 'Eliminado'],
|
||||
Cancelado: ['Programado', 'Publicado'],
|
||||
Eliminado: [],
|
||||
};
|
||||
|
||||
/**
|
||||
* Transiciones que un Líder (cualquier autorización) puede hacer en SUS
|
||||
* equipos: publicar es de SuperAdmin/Dev; el líder inicia y finaliza.
|
||||
*/
|
||||
export const SERVICIO_EQUIPO_TRANSICIONES_LIDER: Record<string, string[]> = {
|
||||
Publicado: ['EnCurso', 'Finalizado'],
|
||||
EnCurso: ['Finalizado'],
|
||||
};
|
||||
|
|
|
|||
|
|
@ -226,6 +226,7 @@ export class ServicioController {
|
|||
idServicio,
|
||||
dto,
|
||||
user,
|
||||
dto.idEquipo,
|
||||
);
|
||||
|
||||
if (result.boolean) {
|
||||
|
|
@ -247,11 +248,102 @@ export class ServicioController {
|
|||
return apiResult;
|
||||
}
|
||||
|
||||
/** Estado de UN equipo del servicio (multi-equipo). */
|
||||
@Patch(':idServicio/equipo/:idEquipo/estado')
|
||||
@Autorizacion(AutorizacionEnum.SuperAdmin, AutorizacionEnum.Usuario)
|
||||
async cambiarEstadoEquipo(
|
||||
@Req() req: AuthRequest,
|
||||
@Param('idServicio') idServicio: string,
|
||||
@Param('idEquipo') idEquipo: string,
|
||||
@Body() dto: CambiarEstadoServicioDto,
|
||||
): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeServicio.cambiarEstadoEquipo.title,
|
||||
routeServicio.cambiarEstadoEquipo.route,
|
||||
);
|
||||
try {
|
||||
const user = getAuthUser(req);
|
||||
if (!user) {
|
||||
apiResult.code = HttpStatus.UNAUTHORIZED;
|
||||
apiResult.message = 'Token inválido.';
|
||||
return apiResult;
|
||||
}
|
||||
const result = await this.servicioService.cambiarEstado(
|
||||
idServicio,
|
||||
dto,
|
||||
user,
|
||||
idEquipo,
|
||||
);
|
||||
if (result.boolean) {
|
||||
apiResult.status = 'correct';
|
||||
apiResult.code = HttpStatus.OK;
|
||||
apiResult.message = result.message;
|
||||
apiResult.boolean = true;
|
||||
apiResult.rows = result.number;
|
||||
apiResult.data = result.object ? [result.object] : [];
|
||||
} else {
|
||||
apiResult.code = HttpStatus.BAD_REQUEST;
|
||||
apiResult.message = result.message;
|
||||
}
|
||||
} catch (error) {
|
||||
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
apiResult.message = error.message;
|
||||
}
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
/**
|
||||
* Batch: `body.idEquipo` opcional — sin él, Dev/Super aplican a todos
|
||||
* los equipos del servicio y el Líder a los suyos.
|
||||
*/
|
||||
@Patch(':idServicio/equipos/estado')
|
||||
@Autorizacion(AutorizacionEnum.SuperAdmin, AutorizacionEnum.Usuario)
|
||||
async cambiarEstadoEquipos(
|
||||
@Req() req: AuthRequest,
|
||||
@Param('idServicio') idServicio: string,
|
||||
@Body() dto: CambiarEstadoServicioDto,
|
||||
): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeServicio.cambiarEstadoEquipos.title,
|
||||
routeServicio.cambiarEstadoEquipos.route,
|
||||
);
|
||||
try {
|
||||
const user = getAuthUser(req);
|
||||
if (!user) {
|
||||
apiResult.code = HttpStatus.UNAUTHORIZED;
|
||||
apiResult.message = 'Token inválido.';
|
||||
return apiResult;
|
||||
}
|
||||
const result = await this.servicioService.cambiarEstado(
|
||||
idServicio,
|
||||
dto,
|
||||
user,
|
||||
dto.idEquipo,
|
||||
);
|
||||
if (result.boolean) {
|
||||
apiResult.status = 'correct';
|
||||
apiResult.code = HttpStatus.OK;
|
||||
apiResult.message = result.message;
|
||||
apiResult.boolean = true;
|
||||
apiResult.rows = result.number;
|
||||
apiResult.data = result.object ? [result.object] : [];
|
||||
} else {
|
||||
apiResult.code = HttpStatus.BAD_REQUEST;
|
||||
apiResult.message = result.message;
|
||||
}
|
||||
} catch (error) {
|
||||
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
apiResult.message = error.message;
|
||||
}
|
||||
return apiResult;
|
||||
}
|
||||
|
||||
@Post(':idServicio/pin')
|
||||
@Autorizacion(AutorizacionEnum.SuperAdmin)
|
||||
async regenerarPin(
|
||||
@Req() req: AuthRequest,
|
||||
@Param('idServicio') idServicio: string,
|
||||
@Body() body?: { idEquipo?: string },
|
||||
): Promise<ApiResult> {
|
||||
const apiResult = defaultApiResult(
|
||||
routeServicio.regenerarPin.title,
|
||||
|
|
@ -266,7 +358,10 @@ export class ServicioController {
|
|||
return apiResult;
|
||||
}
|
||||
|
||||
const result = await this.servicioService.regenerarPin(idServicio);
|
||||
const result = await this.servicioService.regenerarPin(
|
||||
idServicio,
|
||||
body?.idEquipo,
|
||||
);
|
||||
|
||||
if (result.boolean) {
|
||||
apiResult.status = 'correct';
|
||||
|
|
|
|||
|
|
@ -17,7 +17,15 @@ export const routeServicio = {
|
|||
},
|
||||
cambiarEstado: {
|
||||
route: '[PATCH].../v1/servicios/:idServicio/estado',
|
||||
title: 'Cambiar Estado Servicio',
|
||||
title: 'Cambiar Estado Servicio (sin equipos o batch por alcance)',
|
||||
},
|
||||
cambiarEstadoEquipo: {
|
||||
route: '[PATCH].../v1/servicios/:idServicio/equipo/:idEquipo/estado',
|
||||
title: 'Cambiar Estado de un equipo del servicio',
|
||||
},
|
||||
cambiarEstadoEquipos: {
|
||||
route: '[PATCH].../v1/servicios/:idServicio/equipos/estado',
|
||||
title: 'Cambiar Estado de equipos del servicio (batch)',
|
||||
},
|
||||
remove: {
|
||||
route: '[DELETE].../v1/servicios/:idServicio',
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -2,6 +2,7 @@ import { Module } from '@nestjs/common';
|
|||
import { TypeOrmModule } from '@nestjs/typeorm';
|
||||
import { SolicitudApoyo } from './entities/solicitud-apoyo.entity.js';
|
||||
import { Servicio } from '../servicio/entities/servicio.entity.js';
|
||||
import { ServicioEquipo } from '../servicio-equipo/entities/servicio-equipo.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';
|
||||
|
|
@ -13,6 +14,7 @@ import { SolicitudApoyoController } from './solicitud-apoyo.controller.js';
|
|||
TypeOrmModule.forFeature([
|
||||
SolicitudApoyo,
|
||||
Servicio,
|
||||
ServicioEquipo,
|
||||
Asistencia,
|
||||
EquipoPersona,
|
||||
Persona,
|
||||
|
|
|
|||
|
|
@ -3,11 +3,18 @@ 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 { ServicioEquipo } from '../servicio-equipo/entities/servicio-equipo.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 {
|
||||
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,
|
||||
|
|
@ -19,7 +26,11 @@ import {
|
|||
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';
|
||||
import {
|
||||
AuthUser,
|
||||
isDeveloper,
|
||||
isSuperAdmin,
|
||||
} from '../../common/utils/auth-user.js';
|
||||
|
||||
@Injectable()
|
||||
export class SolicitudApoyoService {
|
||||
|
|
@ -28,6 +39,8 @@ export class SolicitudApoyoService {
|
|||
private solicitudApoyoRepository: Repository<SolicitudApoyo>,
|
||||
@InjectRepository(Servicio)
|
||||
private servicioRepository: Repository<Servicio>,
|
||||
@InjectRepository(ServicioEquipo)
|
||||
private servicioEquipoRepository: Repository<ServicioEquipo>,
|
||||
@InjectRepository(Asistencia)
|
||||
private asistenciaRepository: Repository<Asistencia>,
|
||||
@InjectRepository(EquipoPersona)
|
||||
|
|
@ -48,14 +61,24 @@ export class SolicitudApoyoService {
|
|||
serviceResult.message = 'No existe el servicio.';
|
||||
return serviceResult;
|
||||
}
|
||||
if (servicio.estado !== EstadoServicio.Publicado) {
|
||||
serviceResult.message = 'Solo se puede solicitar apoyo en servicio Publicado.';
|
||||
// El estado vivo es el del EQUIPO solicitante en este servicio.
|
||||
const se = await this.servicioEquipoRepository.findOneBy({
|
||||
idServicio: dto.idServicio,
|
||||
idEquipo: dto.idEquipo,
|
||||
});
|
||||
const estadoVivo = se
|
||||
? se.estado
|
||||
: ((servicio.estado as EstadoServicio | null) ?? null);
|
||||
if (estadoVivo !== EstadoServicio.Publicado) {
|
||||
serviceResult.message =
|
||||
'Solo se puede solicitar apoyo cuando el equipo está Publicado.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
if (!isDeveloper(user)) {
|
||||
if (user.rol !== Rol.Lider) {
|
||||
serviceResult.message = 'Solo el Líder del equipo (o Developer) puede pedir apoyo.';
|
||||
serviceResult.message =
|
||||
'Solo el Líder del equipo (o Developer) puede pedir apoyo.';
|
||||
return serviceResult;
|
||||
}
|
||||
const esLider = await this.equipoPersonaRepository.findOneBy({
|
||||
|
|
@ -64,7 +87,8 @@ export class SolicitudApoyoService {
|
|||
estado: EstadoMiembro.Activo,
|
||||
});
|
||||
if (!esLider) {
|
||||
serviceResult.message = 'Solo el Líder de ese equipo puede solicitar apoyo.';
|
||||
serviceResult.message =
|
||||
'Solo el Líder de ese equipo puede solicitar apoyo.';
|
||||
return serviceResult;
|
||||
}
|
||||
}
|
||||
|
|
@ -88,10 +112,15 @@ export class SolicitudApoyoService {
|
|||
return serviceResult;
|
||||
}
|
||||
|
||||
async findOne(idSolicitudApoyo: string, user: AuthUser): Promise<ServiceResult> {
|
||||
async findOne(
|
||||
idSolicitudApoyo: string,
|
||||
user: AuthUser,
|
||||
): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
|
||||
const result = await this.solicitudApoyoRepository.findOneBy({ idSolicitudApoyo });
|
||||
const result = await this.solicitudApoyoRepository.findOneBy({
|
||||
idSolicitudApoyo,
|
||||
});
|
||||
if (!result) {
|
||||
serviceResult.message = 'No existe la solicitud de apoyo.';
|
||||
return serviceResult;
|
||||
|
|
@ -122,7 +151,8 @@ export class SolicitudApoyoService {
|
|||
const serviceResult = defaultServiceResult();
|
||||
|
||||
try {
|
||||
let query = this.solicitudApoyoRepository.createQueryBuilder('solicitud_apoyo');
|
||||
let query =
|
||||
this.solicitudApoyoRepository.createQueryBuilder('solicitud_apoyo');
|
||||
|
||||
whereConditions.forEach((condition, index) => {
|
||||
const { attribute, value, operator = '=' } = condition;
|
||||
|
|
@ -155,7 +185,10 @@ export class SolicitudApoyoService {
|
|||
throw new Error(`Atributo de orden no permitido: ${orderByAttribute}`);
|
||||
}
|
||||
|
||||
query = query.orderBy(`solicitud_apoyo.${orderByAttribute}`, orderByDirection);
|
||||
query = query.orderBy(
|
||||
`solicitud_apoyo.${orderByAttribute}`,
|
||||
orderByDirection,
|
||||
);
|
||||
|
||||
const totalRegistros = await query.getCount();
|
||||
const skip = (offset - 1) * limit;
|
||||
|
|
@ -180,7 +213,9 @@ export class SolicitudApoyoService {
|
|||
): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
|
||||
const existente = await this.solicitudApoyoRepository.findOneBy({ idSolicitudApoyo });
|
||||
const existente = await this.solicitudApoyoRepository.findOneBy({
|
||||
idSolicitudApoyo,
|
||||
});
|
||||
if (!existente) {
|
||||
serviceResult.message = 'No se encontró la solicitud de apoyo.';
|
||||
return serviceResult;
|
||||
|
|
@ -192,7 +227,8 @@ export class SolicitudApoyoService {
|
|||
}
|
||||
|
||||
const clean: Partial<SolicitudApoyo> = {};
|
||||
if (dto.cuposSolicitados !== undefined) clean.cuposSolicitados = dto.cuposSolicitados;
|
||||
if (dto.cuposSolicitados !== undefined)
|
||||
clean.cuposSolicitados = dto.cuposSolicitados;
|
||||
if (dto.motivo !== undefined) clean.motivo = dto.motivo;
|
||||
|
||||
if (Object.keys(clean).length === 0) {
|
||||
|
|
@ -200,7 +236,10 @@ export class SolicitudApoyoService {
|
|||
return serviceResult;
|
||||
}
|
||||
|
||||
const result = await this.solicitudApoyoRepository.update(idSolicitudApoyo, clean);
|
||||
const result = await this.solicitudApoyoRepository.update(
|
||||
idSolicitudApoyo,
|
||||
clean,
|
||||
);
|
||||
|
||||
serviceResult.boolean = result.affected === 1;
|
||||
serviceResult.message = 'Solicitud de apoyo actualizada.';
|
||||
|
|
@ -212,10 +251,15 @@ export class SolicitudApoyoService {
|
|||
/**
|
||||
* Aceptar apoyo: elegibilidad + cupo atómico + fila Asistencia Apoyo.
|
||||
*/
|
||||
async aceptar(idSolicitudApoyo: string, user: AuthUser): Promise<ServiceResult> {
|
||||
async aceptar(
|
||||
idSolicitudApoyo: string,
|
||||
user: AuthUser,
|
||||
): Promise<ServiceResult> {
|
||||
const serviceResult = defaultServiceResult();
|
||||
|
||||
const solicitud = await this.solicitudApoyoRepository.findOneBy({ idSolicitudApoyo });
|
||||
const solicitud = await this.solicitudApoyoRepository.findOneBy({
|
||||
idSolicitudApoyo,
|
||||
});
|
||||
if (!solicitud) {
|
||||
serviceResult.message = 'No existe la solicitud de apoyo.';
|
||||
return serviceResult;
|
||||
|
|
@ -232,7 +276,9 @@ export class SolicitudApoyoService {
|
|||
}
|
||||
|
||||
const solicitante = user.idPersona;
|
||||
const persona = await this.personaRepository.findOneBy({ idPersona: solicitante });
|
||||
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;
|
||||
|
|
@ -243,13 +289,16 @@ export class SolicitudApoyoService {
|
|||
}
|
||||
|
||||
// no puede ser del equipo que pidió apoyo
|
||||
const esDelEquipoSolicitante = await this.equipoPersonaRepository.findOneBy({
|
||||
idPersona: solicitante,
|
||||
idEquipo: solicitud.idEquipo,
|
||||
estado: EstadoMiembro.Activo,
|
||||
});
|
||||
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ó.';
|
||||
serviceResult.message =
|
||||
'No puede apoyar: pertenece al equipo que solicitó.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
|
|
@ -276,7 +325,8 @@ export class SolicitudApoyoService {
|
|||
idPersona: solicitante,
|
||||
});
|
||||
if (yaAsistio) {
|
||||
serviceResult.message = 'Ya tiene una fila de asistencia en este servicio.';
|
||||
serviceResult.message =
|
||||
'Ya tiene una fila de asistencia en este servicio.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
|
|
@ -301,7 +351,10 @@ export class SolicitudApoyoService {
|
|||
.execute();
|
||||
|
||||
if (upd.affected === 0) {
|
||||
return { ok: false, message: 'Cupos agotados o convocatoria no válida.' };
|
||||
return {
|
||||
ok: false,
|
||||
message: 'Cupos agotados o convocatoria no válida.',
|
||||
};
|
||||
}
|
||||
|
||||
await manager.insert(Asistencia, {
|
||||
|
|
@ -324,12 +377,16 @@ export class SolicitudApoyoService {
|
|||
return serviceResult;
|
||||
}
|
||||
|
||||
async cancelar(idSolicitudApoyo: string, user: AuthUser): Promise<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.';
|
||||
serviceResult.message =
|
||||
'Solo SuperAdmin/Developer pueden cancelar convocatorias.';
|
||||
return serviceResult;
|
||||
}
|
||||
|
||||
|
|
@ -349,7 +406,8 @@ export class SolicitudApoyoService {
|
|||
}
|
||||
|
||||
private async puedeVer(user: AuthUser, s: SolicitudApoyo): Promise<boolean> {
|
||||
if (isDeveloper(user) || isSuperAdmin(user) || user.rol === Rol.Admin) return true;
|
||||
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({
|
||||
|
|
|
|||
|
|
@ -1,5 +1,11 @@
|
|||
import { ApiProperty } from '@nestjs/swagger';
|
||||
import { IsEnum, IsNotEmpty, IsOptional, IsString } from 'class-validator';
|
||||
import {
|
||||
IsEnum,
|
||||
IsNotEmpty,
|
||||
IsOptional,
|
||||
IsString,
|
||||
Matches,
|
||||
} from 'class-validator';
|
||||
import { TipoTurno } from '../../../common/enums/tipos.enum.js';
|
||||
import { EstadoGeneral } from '../../../common/enums/estados.enum.js';
|
||||
|
||||
|
|
@ -24,6 +30,20 @@ export class TurnoDto {
|
|||
@IsNotEmpty()
|
||||
horaFin: string;
|
||||
|
||||
@ApiProperty({
|
||||
required: false,
|
||||
description:
|
||||
'Hora límite de ingreso HH:MM (opcional). Vacía = se usa horaInicio. ' +
|
||||
'Con configuracion.tolerancia define el Atrasado.',
|
||||
example: '06:30',
|
||||
})
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@Matches(/^([01]\d|2[0-3]):[0-5]\d$/, {
|
||||
message: 'limiteIngreso debe tener formato HH:MM.',
|
||||
})
|
||||
limiteIngreso?: string | null;
|
||||
|
||||
@ApiProperty({ enum: EstadoGeneral, required: false })
|
||||
@IsEnum(EstadoGeneral)
|
||||
@IsOptional()
|
||||
|
|
|
|||
|
|
@ -21,6 +21,13 @@ export class Turno {
|
|||
@Column({ type: 'varchar' })
|
||||
horaFin: string;
|
||||
|
||||
/**
|
||||
* Hora límite para llegar a tiempo (HH:MM). Si es null se usa `horaInicio`.
|
||||
* El `Atrasado` se decide con esta hora + `configuracion.tolerancia`.
|
||||
*/
|
||||
@Column({ type: 'varchar', nullable: true })
|
||||
limiteIngreso?: string | null;
|
||||
|
||||
@Column({
|
||||
type: 'varchar',
|
||||
default: EstadoGeneral.Activo,
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
Loading…
Add table
Reference in a new issue