9no Commit

This commit is contained in:
DillusDev001 2026-10-28 07:50:17 -04:00
parent ea60405fa1
commit 78924159bf
33 changed files with 2570 additions and 490 deletions

View file

@ -8,6 +8,8 @@ services:
- "4002:4002" - "4002:4002"
env_file: env_file:
- .env - .env
environment:
TZ: America/La_Paz
restart: unless-stopped restart: unless-stopped
networks: networks:
- red_postgres - red_postgres

View 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}`);
}

View file

@ -160,9 +160,11 @@ export class AsistenciaController {
return apiResult; 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') @Patch(':idAsistencia')
@Roles(Rol.Lider) @Roles(Rol.Lider, Rol.Estaca, Rol.Servidor)
@Autorizacion(AutorizacionEnum.SuperAdmin)
async update( async update(
@Req() req: AuthRequest, @Req() req: AuthRequest,
@Param('idAsistencia') idAsistencia: string, @Param('idAsistencia') idAsistencia: string,
@ -244,8 +246,10 @@ export class AsistenciaController {
return apiResult; 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') @Post(':idAsistencia/estado')
@Roles(Rol.Lider) @Roles(Rol.Lider, Rol.Estaca)
async setEstado( async setEstado(
@Req() req: AuthRequest, @Req() req: AuthRequest,
@Param('idAsistencia') idAsistencia: string, @Param('idAsistencia') idAsistencia: string,

View file

@ -1,6 +1,6 @@
import { Injectable } from '@nestjs/common'; import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm'; import { InjectRepository } from '@nestjs/typeorm';
import { In, Repository } from 'typeorm'; import { Repository } from 'typeorm';
import { Asistencia } from './entities/asistencia.entity.js'; import { Asistencia } from './entities/asistencia.entity.js';
import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js'; import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js';
import { Reemplazo } from '../reemplazo/entities/reemplazo.entity.js'; import { Reemplazo } from '../reemplazo/entities/reemplazo.entity.js';
@ -31,6 +31,10 @@ import {
TipoAsistencia, TipoAsistencia,
} from '../../common/enums/tipos.enum.js'; } from '../../common/enums/tipos.enum.js';
import { Rol } from '../../common/enums/rol.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 { ASISTENCIA_FIND_WHITELIST } from './asistencia.constants.js';
import { import {
AuthUser, AuthUser,
@ -95,24 +99,26 @@ export class AsistenciaService {
return 0; return 0;
} }
const servicios = await this.servicioRepository.find({ const activas = convocatorias.filter(
where: { (c) =>
idServicio: In(convocatorias.map((c) => c.idServicio)), c.estado === EstadoServicio.Publicado ||
estado: In([EstadoServicio.Publicado, EstadoServicio.EnCurso]), c.estado === EstadoServicio.EnCurso,
}, );
}); if (!activas.length) {
return 0;
}
let creadas = 0; let creadas = 0;
for (const servicio of servicios) { for (const c of activas) {
const existe = await this.asistenciaRepository.findOneBy({ const existe = await this.asistenciaRepository.findOneBy({
idServicio: servicio.idServicio, idServicio: c.idServicio,
idPersona, idPersona,
}); });
if (existe) { if (existe) {
continue; continue;
} }
await this.asistenciaRepository.insert({ await this.asistenciaRepository.insert({
idServicio: servicio.idServicio, idServicio: c.idServicio,
idEquipo, idEquipo,
idPersona, idPersona,
tipo: TipoAsistencia.Titular, tipo: TipoAsistencia.Titular,
@ -179,22 +185,28 @@ export class AsistenciaService {
); );
}); });
if (user.rol === Rol.Servidor) { // Dev/SuperAdmin: sin scoping (toda la visibilidad del find; el rol
query = query.andWhere('asistencia."idPersona" = :id', { // del usuario puede ser Líder/Estaca y no debe acotar — matriz K).
id: user.idPersona, if (!isDeveloper(user) && !isSuperAdmin(user)) {
}); if (user.rol === Rol.Servidor) {
} else if (user.rol === Rol.Lider || user.rol === Rol.Estaca) { query = query.andWhere('asistencia."idPersona" = :id', {
const misEquipos = await this.equipoPersonaRepository id: user.idPersona,
.createQueryBuilder('ep') });
.select('ep."idEquipo"') } else if (user.rol === Rol.Lider || user.rol === Rol.Estaca) {
.where('ep."idPersona" = :id', { id: user.idPersona }) const misEquipos = await this.equipoPersonaRepository
.andWhere('ep.estado = :e', { e: EstadoMiembro.Activo }) .createQueryBuilder('ep')
.getRawMany(); .select('ep."idEquipo"')
const ids = misEquipos.map((r: { idEquipo: string }) => r.idEquipo); .where('ep."idPersona" = :id', { id: user.idPersona })
if (!ids.length) { .andWhere('ep.estado = :e', { e: EstadoMiembro.Activo })
query = query.andWhere('1 = 0'); .getRawMany();
} else { const ids = misEquipos.map((r: { idEquipo: string }) => r.idEquipo);
query = query.andWhere('asistencia."idEquipo" IN (:...ids)', { ids }); 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; 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> = {}; const clean: Partial<Asistencia> = {};
if (dto.tipo !== undefined) clean.tipo = dto.tipo; if (dto.tipo !== undefined) clean.tipo = dto.tipo;
if (dto.observacion !== undefined) clean.observacion = dto.observacion; if (dto.observacion !== undefined) clean.observacion = dto.observacion;
if (dto.estado !== undefined) clean.estado = dto.estado; 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) { if (Object.keys(clean).length === 0) {
serviceResult.message = 'No hay campos permitidos para actualizar.'; serviceResult.message = 'No hay campos permitidos para actualizar.';
@ -297,13 +317,21 @@ export class AsistenciaService {
return serviceResult; return serviceResult;
} }
// Tanda 2026-10-17: con el servicio 'Finalizado' no se admite ingreso // El estado vivo es el del EQUIPO de esta fila de asistencia.
// (las faltas de los que no ingresaron ya las aplica cambiarEstado al const se = await this.servicioEquipoRepository.findOneBy({
// finalizar). La salida del que sí ingresó sigue permitida ese día. idServicio: asistencia.idServicio,
if ( idEquipo: asistencia.idEquipo,
dto.accion === 'ingreso' && });
servicio.estado === EstadoServicio.Finalizado 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 = serviceResult.message =
'El servicio ya está finalizado: no se puede registrar ingreso.'; 'El servicio ya está finalizado: no se puede registrar ingreso.';
return serviceResult; return serviceResult;
@ -327,7 +355,9 @@ export class AsistenciaService {
serviceResult.message = `Marcado ${dto.metodo} requiere pin.`; serviceResult.message = `Marcado ${dto.metodo} requiere pin.`;
return serviceResult; 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.'; serviceResult.message = 'PIN incorrecto.';
return serviceResult; return serviceResult;
} }
@ -436,9 +466,10 @@ export class AsistenciaService {
} }
/** /**
* Estado al ingresar: `Atrasado` si ya pasó la hora de inicio del turno más * Estado al ingresar: `Atrasado` si ya pasó la hora límite de la primera
* temprano del servicio (sin tolerancia); si no, `Presente`. Sin turnos o * reunión del servicio (`limiteIngreso ?? horaInicio`) más
* sin hora parseable, queda `Presente`. * `configuracion.tolerancia` minutos; si no, `Presente`. Sin turnos o sin
* hora parseable, queda `Presente`.
*/ */
private async estadoMarcado( private async estadoMarcado(
servicio?: Servicio | null, servicio?: Servicio | null,
@ -452,16 +483,31 @@ export class AsistenciaService {
if (!st) return EstadoAsistencia.Presente; if (!st) return EstadoAsistencia.Presente;
const turno = await this.turnoRepository.findOneBy({ idTurno: st.idTurno }); const turno = await this.turnoRepository.findOneBy({ idTurno: st.idTurno });
if (!turno?.horaInicio) return EstadoAsistencia.Presente; if (!turno) return EstadoAsistencia.Presente;
const hora = // Hora de referencia: límite de ingreso o, si no, inicio de la reunión.
turno.horaInicio.length === 5 const horaRef =
? `${turno.horaInicio}:00` (turno.limiteIngreso && turno.limiteIngreso.length >= 5
: turno.horaInicio; ? turno.limiteIngreso
const inicio = new Date(`${servicio.fecha}T${hora}`); : turno.horaInicio) ?? null;
if (Number.isNaN(inicio.getTime())) return EstadoAsistencia.Presente; 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.Atrasado
: EstadoAsistencia.Presente; : EstadoAsistencia.Presente;
} }

View file

@ -101,15 +101,15 @@ export class UpdateAsistenciaDto {
@IsOptional() @IsOptional()
observacion?: string; observacion?: string;
@ApiProperty({ required: false }) @ApiProperty({ required: false, nullable: true })
@IsDateString() @IsDateString()
@IsOptional() @IsOptional()
fecIngreso?: string; fecIngreso?: string | null;
@ApiProperty({ required: false }) @ApiProperty({ required: false, nullable: true })
@IsDateString() @IsDateString()
@IsOptional() @IsOptional()
fecSalida?: string; fecSalida?: string | null;
@ApiProperty({ enum: MetodoMarcado, required: false }) @ApiProperty({ enum: MetodoMarcado, required: false })
@IsEnum(MetodoMarcado) @IsEnum(MetodoMarcado)

View file

@ -5,6 +5,7 @@ import { Configuracion } from './entities/configuracion.entity.js';
import { ConfiguracionDto } from './dto/configuracion.dto.js'; import { ConfiguracionDto } from './dto/configuracion.dto.js';
import { UpdateConfiguracionDto } from './dto/update-configuracion.dto.js'; import { UpdateConfiguracionDto } from './dto/update-configuracion.dto.js';
import { defaultServiceResult, ServiceResult } from '../../common/interfaces/service.result.js'; import { defaultServiceResult, ServiceResult } from '../../common/interfaces/service.result.js';
import { ZONA_HORA_DEFAULT, ZONA_HORA_RE } from '../../common/utils/zona-horaria.js';
@Injectable() @Injectable()
export class ConfiguracionService { export class ConfiguracionService {
@ -47,11 +48,28 @@ export class ConfiguracionService {
serviceResult.message = 'La distancia debe ser mayor a 0.'; serviceResult.message = 'La distancia debe ser mayor a 0.';
return serviceResult; 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({ const entity = this.configuracionRepository.create({
lat: configuracionDto.lat, lat: configuracionDto.lat,
lng: configuracionDto.lng, lng: configuracionDto.lng,
distancia: configuracionDto.distancia, distancia: configuracionDto.distancia,
tolerancia: configuracionDto.tolerancia ?? 0,
zonaHoraria: configuracionDto.zonaHoraria ?? ZONA_HORA_DEFAULT,
openwaSessionId: configuracionDto.openwaSessionId ?? null, openwaSessionId: configuracionDto.openwaSessionId ?? null,
}); });
const result = await this.configuracionRepository.save(entity); const result = await this.configuracionRepository.save(entity);
@ -81,6 +99,21 @@ export class ConfiguracionService {
serviceResult.message = 'La distancia debe ser mayor a 0.'; serviceResult.message = 'La distancia debe ser mayor a 0.';
return serviceResult; 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> = {}; const clean: Partial<Configuracion> = {};
if (updateConfiguracionDto.lat !== undefined) clean.lat = updateConfiguracionDto.lat; if (updateConfiguracionDto.lat !== undefined) clean.lat = updateConfiguracionDto.lat;
@ -88,6 +121,12 @@ export class ConfiguracionService {
if (updateConfiguracionDto.distancia !== undefined) { if (updateConfiguracionDto.distancia !== undefined) {
clean.distancia = updateConfiguracionDto.distancia; clean.distancia = updateConfiguracionDto.distancia;
} }
if (updateConfiguracionDto.tolerancia !== undefined) {
clean.tolerancia = updateConfiguracionDto.tolerancia;
}
if (updateConfiguracionDto.zonaHoraria !== undefined) {
clean.zonaHoraria = updateConfiguracionDto.zonaHoraria;
}
if (updateConfiguracionDto.openwaSessionId !== undefined) { if (updateConfiguracionDto.openwaSessionId !== undefined) {
clean.openwaSessionId = updateConfiguracionDto.openwaSessionId; clean.openwaSessionId = updateConfiguracionDto.openwaSessionId;
} }

View file

@ -1,5 +1,17 @@
import { ApiProperty } from '@nestjs/swagger'; 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 { export class ConfiguracionDto {
@ApiProperty() @ApiProperty()
@ -17,6 +29,32 @@ export class ConfiguracionDto {
@IsNotEmpty() @IsNotEmpty()
distancia: number; 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' }) @ApiProperty({ required: false, description: 'SessionId de OpenWA' })
@IsString() @IsString()
@IsOptional() @IsOptional()

View file

@ -14,6 +14,20 @@ export class Configuracion {
@Column('double precision') @Column('double precision')
distancia: number; 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 */ /** SessionId de OpenWA (Easy API). Si es null se usa OPENWA_SESSION_ID de .env */
@Column({ type: 'varchar', nullable: true }) @Column({ type: 'varchar', nullable: true })
openwaSessionId?: string | null; openwaSessionId?: string | null;

View 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 };
}
}

View 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;
}

View 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;
}

View file

@ -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 { 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 } from '../../common/decorators/autorizacion.decorator.js';
import { Autorizacion as AutorizacionEnum } from '../../common/enums/rol.enum.js'; import { Autorizacion as AutorizacionEnum } from '../../common/enums/rol.enum.js';
import { import {
ApiResult, ApiResult,
defaultApiResult, defaultApiResult,
} from '../../common/interfaces/api.result.js'; } 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 { PurgaDto } from './dto/purga.dto.js';
import {
BackupDto,
EliminarBackupDto,
RestaurarDto,
} from './dto/backup.dto.js';
import { MantenimientoService } from './mantenimiento.service.js'; import { MantenimientoService } from './mantenimiento.service.js';
import { BackupService } from './backup.service.js';
import { routeMantenimiento } from './mantenimiento.router.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') @ApiTags('mantenimiento')
@ApiBearerAuth() @ApiBearerAuth()
@Controller('mantenimiento') @Controller('mantenimiento')
export class MantenimientoController { 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 /// Borrado físico total por categoría: dryRun cuenta; ejecutar exige
/// `confirmacion === 'ELIMINAR'`. /// `confirmacion === 'ELIMINAR'`.
@ -59,4 +93,348 @@ export class MantenimientoController {
return apiResult; 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;
}
} }

View file

@ -12,8 +12,10 @@ import { ServicioTurno } from '../servicio-turno/entities/servicio-turno.entity.
import { Servicio } from '../servicio/entities/servicio.entity.js'; import { Servicio } from '../servicio/entities/servicio.entity.js';
import { SolicitudApoyo } from '../solicitud-apoyo/entities/solicitud-apoyo.entity.js'; import { SolicitudApoyo } from '../solicitud-apoyo/entities/solicitud-apoyo.entity.js';
import { Turno } from '../turno/entities/turno.entity.js'; import { Turno } from '../turno/entities/turno.entity.js';
import { Backup } from './entities/backup.entity.js';
import { MantenimientoController } from './mantenimiento.controller.js'; import { MantenimientoController } from './mantenimiento.controller.js';
import { MantenimientoService } from './mantenimiento.service.js'; import { MantenimientoService } from './mantenimiento.service.js';
import { BackupService } from './backup.service.js';
@Module({ @Module({
imports: [ imports: [
@ -30,9 +32,10 @@ import { MantenimientoService } from './mantenimiento.service.js';
Servicio, Servicio,
Turno, Turno,
Persona, Persona,
Backup,
]), ]),
], ],
controllers: [MantenimientoController], controllers: [MantenimientoController],
providers: [MantenimientoService], providers: [MantenimientoService, BackupService],
}) })
export class MantenimientoModule {} export class MantenimientoModule {}

View file

@ -3,4 +3,40 @@ export const routeMantenimiento = {
route: '[POST].../v1/mantenimiento/purga', route: '[POST].../v1/mantenimiento/purga',
title: 'Purga de datos (Developer)', 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)',
},
}; };

View file

@ -13,6 +13,7 @@ import { ServicioTurno } from '../servicio-turno/entities/servicio-turno.entity.
import { Servicio } from '../servicio/entities/servicio.entity.js'; import { Servicio } from '../servicio/entities/servicio.entity.js';
import { SolicitudApoyo } from '../solicitud-apoyo/entities/solicitud-apoyo.entity.js'; import { SolicitudApoyo } from '../solicitud-apoyo/entities/solicitud-apoyo.entity.js';
import { Turno } from '../turno/entities/turno.entity.js'; import { Turno } from '../turno/entities/turno.entity.js';
import { EstadoGeneral } from '../../common/enums/estados.enum.js';
import { import {
defaultServiceResult, defaultServiceResult,
ServiceResult, ServiceResult,
@ -194,4 +195,96 @@ export class MantenimientoService {
return serviceResult; 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('');
}
} }

View file

@ -2,6 +2,7 @@ import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { Reemplazo } from './entities/reemplazo.entity.js'; import { Reemplazo } from './entities/reemplazo.entity.js';
import { Servicio } from '../servicio/entities/servicio.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 { Asistencia } from '../asistencia/entities/asistencia.entity.js';
import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js'; import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js';
import { Persona } from '../persona/entities/persona.entity.js'; import { Persona } from '../persona/entities/persona.entity.js';
@ -11,7 +12,14 @@ import { ReemplazoController } from './reemplazo.controller.js';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([Reemplazo, Servicio, Asistencia, EquipoPersona, Persona]), TypeOrmModule.forFeature([
Reemplazo,
Servicio,
ServicioEquipo,
Asistencia,
EquipoPersona,
Persona,
]),
RealtimeModule, RealtimeModule,
], ],
exports: [ReemplazoService, TypeOrmModule], exports: [ReemplazoService, TypeOrmModule],

View file

@ -4,14 +4,15 @@ import { Repository } from 'typeorm';
import { EventsService } from '../../common/services/events.service.js'; import { EventsService } from '../../common/services/events.service.js';
import { Reemplazo } from './entities/reemplazo.entity.js'; import { Reemplazo } from './entities/reemplazo.entity.js';
import { Servicio } from '../servicio/entities/servicio.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 { Asistencia } from '../asistencia/entities/asistencia.entity.js';
import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js'; import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js';
import { Persona } from '../persona/entities/persona.entity.js'; import { Persona } from '../persona/entities/persona.entity.js';
import { AceptarReemplazoDto, ReemplazoDto } from './dto/reemplazo.dto.js';
import { import {
AceptarReemplazoDto, defaultServiceResult,
ReemplazoDto, ServiceResult,
} from './dto/reemplazo.dto.js'; } 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 { WhereCondition } from '../../common/types/query-builder.types.js';
import { import {
EstadoAsistencia, EstadoAsistencia,
@ -23,7 +24,11 @@ import {
import { TipoAsistencia } from '../../common/enums/tipos.enum.js'; import { TipoAsistencia } from '../../common/enums/tipos.enum.js';
import { Rol } from '../../common/enums/rol.enum.js'; import { Rol } from '../../common/enums/rol.enum.js';
import { REMPLAZO_FIND_WHITELIST } from './reemplazo.constants.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() @Injectable()
export class ReemplazoService { export class ReemplazoService {
@ -34,6 +39,8 @@ export class ReemplazoService {
private reemplazoRepository: Repository<Reemplazo>, private reemplazoRepository: Repository<Reemplazo>,
@InjectRepository(Servicio) @InjectRepository(Servicio)
private servicioRepository: Repository<Servicio>, private servicioRepository: Repository<Servicio>,
@InjectRepository(ServicioEquipo)
private servicioEquipoRepository: Repository<ServicioEquipo>,
@InjectRepository(Asistencia) @InjectRepository(Asistencia)
private asistenciaRepository: Repository<Asistencia>, private asistenciaRepository: Repository<Asistencia>,
@InjectRepository(EquipoPersona) @InjectRepository(EquipoPersona)
@ -59,10 +66,6 @@ export class ReemplazoService {
serviceResult.message = 'No existe el servicio.'; serviceResult.message = 'No existe el servicio.';
return serviceResult; 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({ const membresia = await this.equipoPersonaRepository.findOneBy({
idPersona: idPersonaTitular, idPersona: idPersonaTitular,
@ -73,12 +76,28 @@ export class ReemplazoService {
return serviceResult; 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({ const asistencia = await this.asistenciaRepository.findOneBy({
idServicio: dto.idServicio, idServicio: dto.idServicio,
idPersona: idPersonaTitular, idPersona: idPersonaTitular,
}); });
if (!asistencia) { 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; return serviceResult;
} }
if (asistencia.tipo !== TipoAsistencia.Titular) { if (asistencia.tipo !== TipoAsistencia.Titular) {
@ -96,7 +115,8 @@ export class ReemplazoService {
estado: EstadoConvocatoria.Abierto, estado: EstadoConvocatoria.Abierto,
}); });
if (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; return serviceResult;
} }
@ -106,7 +126,8 @@ export class ReemplazoService {
estado: EstadoConvocatoria.Cubierto, estado: EstadoConvocatoria.Cubierto,
}); });
if (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; return serviceResult;
} }
@ -130,7 +151,7 @@ export class ReemplazoService {
const elegibles = await this.personaRepository const elegibles = await this.personaRepository
.createQueryBuilder('p') .createQueryBuilder('p')
.where('p.estado = :e', { e: EstadoGeneral.Activo }) .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 }) .andWhere('p."idPersona" != :titular', { titular: idPersonaTitular })
.getMany(); .getMany();
const ids = elegibles.map((p) => p.idPersona); const ids = elegibles.map((p) => p.idPersona);
@ -142,7 +163,9 @@ export class ReemplazoService {
data: { idReemplazo: result.idReemplazo, idServicio: dto.idServicio }, data: { idReemplazo: result.idReemplazo, idServicio: dto.idServicio },
}); });
} catch (error) { } 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'. * 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 serviceResult = defaultServiceResult();
const reemplazo = await this.reemplazoRepository.findOneBy({ idReemplazo }); const reemplazo = await this.reemplazoRepository.findOneBy({ idReemplazo });
@ -298,7 +325,9 @@ export class ReemplazoService {
} }
const solicitante = dto.idPersonaReemplazo ?? user.idPersona; 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) { if (!persona || persona.estado !== EstadoGeneral.Activo) {
serviceResult.message = 'El reemplazante no existe o no está activo.'; serviceResult.message = 'El reemplazante no existe o no está activo.';
return serviceResult; return serviceResult;
@ -369,7 +398,9 @@ export class ReemplazoService {
idReemplazo, idReemplazo,
}) })
.where('"idServicio" = :idServicio', { idServicio: reemplazo.idServicio }) .where('"idServicio" = :idServicio', { idServicio: reemplazo.idServicio })
.andWhere('"idPersona" = :idTitular', { idTitular: reemplazo.idPersonaTitular }) .andWhere('"idPersona" = :idTitular', {
idTitular: reemplazo.idPersonaTitular,
})
.execute(); .execute();
serviceResult.boolean = true; serviceResult.boolean = true;
@ -386,7 +417,9 @@ export class ReemplazoService {
data: { idReemplazo }, data: { idReemplazo },
}); });
} catch (error) { } 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({ const servicio = await this.servicioRepository.findOneBy({
idServicio: reemplazo.idServicio, 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 = const servicioIniciado =
servicio?.estado === EstadoServicio.EnCurso || estadoVivo === EstadoServicio.EnCurso ||
servicio?.estado === EstadoServicio.Finalizado; estadoVivo === EstadoServicio.Finalizado;
const esTitular = user.idPersona === reemplazo.idPersonaTitular; const esTitular = user.idPersona === reemplazo.idPersonaTitular;
const puedeAdmin = isDeveloper(user) || isSuperAdmin(user); const puedeAdmin = isDeveloper(user) || isSuperAdmin(user);
if (esTitular && !puedeAdmin) { if (esTitular && !puedeAdmin) {
if (servicioIniciado) { if (servicioIniciado) {
serviceResult.message = serviceResult.message = 'No puede cancelar: el servicio ya inició.';
'No puede cancelar: el servicio ya inició.';
return serviceResult; return serviceResult;
} }
@ -442,8 +481,12 @@ export class ReemplazoService {
idReemplazo: null, idReemplazo: null,
tipo: TipoAsistencia.Titular, tipo: TipoAsistencia.Titular,
}) })
.where('"idServicio" = :idServicio', { idServicio: reemplazo.idServicio }) .where('"idServicio" = :idServicio', {
.andWhere('"idPersona" = :idTitular', { idTitular: reemplazo.idPersonaTitular }) idServicio: reemplazo.idServicio,
})
.andWhere('"idPersona" = :idTitular', {
idTitular: reemplazo.idPersonaTitular,
})
.execute(); .execute();
}); });
@ -475,8 +518,12 @@ export class ReemplazoService {
} }
private async puedeVer(user: AuthUser, r: Reemplazo): Promise<boolean> { private async puedeVer(user: AuthUser, r: Reemplazo): Promise<boolean> {
if (isDeveloper(user) || isSuperAdmin(user) || user.rol === Rol.Admin) return true; if (isDeveloper(user) || isSuperAdmin(user) || user.rol === Rol.Admin)
if (r.idPersonaTitular === user.idPersona || r.idPersonaReemplazo === user.idPersona) { return true;
if (
r.idPersonaTitular === user.idPersona ||
r.idPersonaReemplazo === user.idPersona
) {
return true; return true;
} }
if (user.rol === Rol.Lider || user.rol === Rol.Estaca) { if (user.rol === Rol.Lider || user.rol === Rol.Estaca) {

View file

@ -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). */ /** Fila cruda de los reportes (JSON para el front, base de las tablas PDF). */
type Fila = Record<string, unknown>; 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 { interface Col {
header: string; header: string;
width: number; width: number;
@ -63,12 +71,33 @@ interface DatosReporte {
control?: EncabezadoControl; control?: EncabezadoControl;
} }
/** Estados de servicio "realizados" (para los 4 reportes de rango). */
const ESTADOS_REALIZADO = [ const ESTADOS_REALIZADO = [
EstadoServicio.Publicado, EstadoServicio.Publicado,
EstadoServicio.EnCurso, EstadoServicio.EnCurso,
EstadoServicio.Finalizado, 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 = [ const MESES_CORTOS = [
'Ene.', 'Ene.',
'Feb.', 'Feb.',
@ -149,7 +178,7 @@ export class ReportesService {
to_char(fecha, 'YYYY-MM-DD') AS fecha, to_char(fecha, 'YYYY-MM-DD') AS fecha,
estado estado
FROM servicio FROM servicio
WHERE "idServicio" = $1 AND estado <> $2`, WHERE "idServicio" = $1 AND estado IS DISTINCT FROM $2`,
[idServicio, EstadoServicio.Eliminado], [idServicio, EstadoServicio.Eliminado],
); );
if (!servicioRows.length) { if (!servicioRows.length) {
@ -158,30 +187,40 @@ export class ReportesService {
// Convocados con su nombre (para el selector de equipo del front). // Convocados con su nombre (para el selector de equipo del front).
const convocados: Fila[] = await manager.query( const convocados: Fila[] = await manager.query(
`SELECT se."idEquipo", e."nombreEquipo" `SELECT se."idEquipo", e."nombreEquipo", se.estado
FROM servicio_equipo se FROM servicio_equipo se
JOIN equipo e ON e."idEquipo" = se."idEquipo" JOIN equipo e ON e."idEquipo" = se."idEquipo"
WHERE se."idServicio" = $1 WHERE se."idServicio" = $1
AND se.estado <> $2
ORDER BY e."nombreEquipo"`, ORDER BY e."nombreEquipo"`,
[idServicio], [idServicio, EstadoServicio.Eliminado],
); );
// Scoping Líder: solo sus equipos (membresía Activa ∩ convocados). // Scoping 10.1: la membresía ACTIVA en un equipo convocado manda
let equipos: string[] | null = await this.equiposScope(user); // primero (aunque el usuario sea Dev/SuperAdmin — así un SuperAdmin
if (equipos !== null) { // que además es Líder no se come los otros equipos); Dev/Super sin
const set = new Set(equipos); // membresía en el servicio → vista global.
equipos = convocados const esGlobal = isDeveloper(user) || isSuperAdmin(user);
.map((c) => c.idEquipo as string) const membresias: { idEquipo: string }[] = await manager.query(
.filter((id) => set.has(id)); `SELECT "idEquipo" FROM equipo_persona
if (!equipos.length) { 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( throw new ForbiddenException(
'Solo el líder de un equipo convocado del servicio puede ver el reporte.', '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 // 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)); const convocadoSet = new Set(convocados.map((c) => c.idEquipo as string));
if (idEquipo) { if (idEquipo) {
if (!convocadoSet.has(idEquipo)) { if (!convocadoSet.has(idEquipo)) {
@ -189,11 +228,27 @@ export class ReportesService {
'El equipo no está convocado en el servicio.', '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.'); 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 → // Título del reporte: un equipo → "Equipo X - Reporte"; Todos →
// "Ministerio Ser - Reporte". // "Ministerio Ser - Reporte".
const nombreEquipoSel = idEquipo const nombreEquipoSel = idEquipo
@ -245,14 +300,23 @@ export class ReportesService {
JOIN persona p ON p."idPersona" = a."idPersona" JOIN persona p ON p."idPersona" = a."idPersona"
JOIN equipo e ON e."idEquipo" = a."idEquipo" JOIN equipo e ON e."idEquipo" = a."idEquipo"
WHERE ${whereFilas} WHERE ${whereFilas}
ORDER BY e."nombreEquipo", p.apellidos, p.nombres`, ORDER BY a."fecIngreso" ASC NULLS LAST,
e."nombreEquipo", p.apellidos, p.nombres`,
paramsFilas, paramsFilas,
); );
// Subrutina de la tanda: servidores activos sin ingreso en 3 meses // Subrutina de Inhabilitado (3 meses sin ingreso → marca a la persona,
// calendario → Inhabilitado (solo al generar este reporte). No es un // acotada a los equipos de ESTE reporte): **apagada por ahora** con
// bloqueo: la persona sigue pudiendo entrar y marcar (rehabilita sola). // EVALUAR_INHABILITADOS (decisión 2026-10-27). La persona ya marcada
const inhabilitados = await this.evaluarInhabilitados(); // 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. // `equiposVisibles` acota el selector del front al scoping del líder.
const equiposVisibles = const equiposVisibles =
@ -286,7 +350,7 @@ export class ReportesService {
const scope = await this.equiposScope(user); const scope = await this.equiposScope(user);
const filtros: string[] = [ const filtros: string[] = [
's.estado = ANY($1)', SQL_ESTADO_REALIZADO,
's.fecha >= $2::date', 's.fecha >= $2::date',
's.fecha <= $3::date', 's.fecha <= $3::date',
]; ];
@ -348,7 +412,7 @@ export class ReportesService {
const scope = await this.equiposScope(user); const scope = await this.equiposScope(user);
const filtros: string[] = [ const filtros: string[] = [
's.estado = ANY($1)', SQL_ESTADO_REALIZADO,
's.fecha >= $2::date', 's.fecha >= $2::date',
's.fecha <= $3::date', 's.fecha <= $3::date',
]; ];
@ -396,7 +460,7 @@ export class ReportesService {
const filtros: string[] = [ const filtros: string[] = [
`a.estado IN ('Falta','Permiso')`, `a.estado IN ('Falta','Permiso')`,
's.estado = ANY($1)', SQL_ESTADO_REALIZADO,
's.fecha >= $2::date', 's.fecha >= $2::date',
's.fecha <= $3::date', 's.fecha <= $3::date',
]; ];
@ -447,7 +511,7 @@ export class ReportesService {
const scope = await this.equiposScope(user); const scope = await this.equiposScope(user);
const filtros: string[] = [ const filtros: string[] = [
's.estado = ANY($1)', SQL_ESTADO_REALIZADO,
's.fecha >= $2::date', 's.fecha >= $2::date',
's.fecha <= $3::date', 's.fecha <= $3::date',
]; ];
@ -484,11 +548,13 @@ export class ReportesService {
// ------------------------------------------------------- inhabilitados // ------------------------------------------------------- inhabilitados
/** /**
* Servidores con membresía activa, `estado = Activo` y **cero ingresos** * Servidores con membresía activa **en `idsEquipo`** (los equipos del
* (Presente/Atrasado con `fecIngreso`) en los últimos 3 meses calendario * reporte), `estado = Activo` y **cero ingresos** (Presente/Atrasado con
* → pasan a `Inhabilitado`. Devuelve los marcados en esta corrida. * `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 manager = this.personaRepository.manager;
const candidatos: Fila[] = await manager.query( const candidatos: Fila[] = await manager.query(
`SELECT p."idPersona", `SELECT p."idPersona",
@ -497,11 +563,12 @@ export class ReportesService {
FROM persona p FROM persona p
WHERE p.rol = $1 WHERE p.rol = $1
AND p.estado = $2 AND p.estado = $2
AND p.autorizacion = $6 AND p.autorizacion = $7
AND EXISTS ( AND EXISTS (
SELECT 1 FROM equipo_persona ep SELECT 1 FROM equipo_persona ep
WHERE ep."idPersona" = p."idPersona" WHERE ep."idPersona" = p."idPersona"
AND ep.estado = $3 AND ep.estado = $3
AND ep."idEquipo" = ANY($6::uuid[])
) )
AND NOT EXISTS ( AND NOT EXISTS (
SELECT 1 FROM asistencia a SELECT 1 FROM asistencia a
@ -516,6 +583,7 @@ export class ReportesService {
EstadoMiembro.Activo, EstadoMiembro.Activo,
EstadoAsistencia.Presente, EstadoAsistencia.Presente,
EstadoAsistencia.Atrasado, EstadoAsistencia.Atrasado,
`{${idsEquipo.join(',')}}`,
Autorizacion.Usuario, Autorizacion.Usuario,
], ],
); );
@ -672,8 +740,9 @@ export class ReportesService {
return serviceResult; return serviceResult;
} }
// El método de datos por servicio se separa para poder reutilizarlo en el // El método de datos por servicio se separa para poder reutilizarlo en
// PDF con su side-effect de inhabilitados incluido. // el PDF (la subrutina de inhabilitados está apagada: ver
// EVALUAR_INHABILITADOS).
private async datosAsistenciaServicio( private async datosAsistenciaServicio(
idServicio: string | undefined, idServicio: string | undefined,
user: AuthUser | null, user: AuthUser | null,

View file

@ -1,4 +1,5 @@
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm'; import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
import { EstadoServicio } from '../../../common/enums/estados.enum.js';
@Entity('servicio_equipo') @Entity('servicio_equipo')
export class ServicioEquipo { export class ServicioEquipo {
@ -13,4 +14,21 @@ export class ServicioEquipo {
@Column({ type: 'uuid' }) @Column({ type: 'uuid' })
asignadoPor: string; 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;
} }

View file

@ -1 +1,6 @@
export const SERVICIO_EQUIPO_FIND_WHITELIST = ['idServicio', 'idEquipo', 'asignadoPor']; export const SERVICIO_EQUIPO_FIND_WHITELIST = [
'idServicio',
'idEquipo',
'asignadoPor',
'estado',
];

View file

@ -4,7 +4,10 @@ import { Repository } from 'typeorm';
import { ServicioEquipo } from './entities/servicio-equipo.entity.js'; import { ServicioEquipo } from './entities/servicio-equipo.entity.js';
import { Servicio } from '../servicio/entities/servicio.entity.js'; import { Servicio } from '../servicio/entities/servicio.entity.js';
import { ServicioEquipoDto } from './dto/servicio-equipo.dto.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 { WhereCondition } from '../../common/types/query-builder.types.js';
import { EstadoServicio } from '../../common/enums/estados.enum.js'; import { EstadoServicio } from '../../common/enums/estados.enum.js';
import { SERVICIO_EQUIPO_FIND_WHITELIST } from './servicio-equipo.constants.js'; import { SERVICIO_EQUIPO_FIND_WHITELIST } from './servicio-equipo.constants.js';
@ -28,13 +31,18 @@ export class ServicioEquipoService {
serviceResult.message = 'No existe el servicio.'; serviceResult.message = 'No existe el servicio.';
return serviceResult; return serviceResult;
} }
if (servicio.estado !== EstadoServicio.Programado) { if (servicio.estado === EstadoServicio.Eliminado) {
serviceResult.message = serviceResult.message =
'Solo se pueden convocar equipos a servicios en estado Programado.'; 'No se pueden convocar equipos a un servicio eliminado.';
return serviceResult; 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); const result = await this.servicioEquipoRepository.save(entity);
serviceResult.boolean = true; serviceResult.boolean = true;
@ -48,7 +56,9 @@ export class ServicioEquipoService {
async findOne(idServicioEquipo: string): Promise<ServiceResult> { async findOne(idServicioEquipo: string): Promise<ServiceResult> {
const serviceResult = defaultServiceResult(); const serviceResult = defaultServiceResult();
const result = await this.servicioEquipoRepository.findOneBy({ idServicioEquipo }); const result = await this.servicioEquipoRepository.findOneBy({
idServicioEquipo,
});
if (result) { if (result) {
serviceResult.boolean = true; serviceResult.boolean = true;
@ -72,7 +82,8 @@ export class ServicioEquipoService {
const serviceResult = defaultServiceResult(); const serviceResult = defaultServiceResult();
try { try {
let query = this.servicioEquipoRepository.createQueryBuilder('servicioEquipo'); let query =
this.servicioEquipoRepository.createQueryBuilder('servicioEquipo');
whereConditions.forEach((condition, index) => { whereConditions.forEach((condition, index) => {
const { attribute, value, operator = '=' } = condition; const { attribute, value, operator = '=' } = condition;
@ -97,7 +108,10 @@ export class ServicioEquipoService {
throw new Error(`Atributo de orden no permitido: ${orderByAttribute}`); 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 totalRegistros = await query.getCount();
const skip = (offset - 1) * limit; const skip = (offset - 1) * limit;

View file

@ -5,7 +5,10 @@ import { ServicioTurno } from './entities/servicio-turno.entity.js';
import { Servicio } from '../servicio/entities/servicio.entity.js'; import { Servicio } from '../servicio/entities/servicio.entity.js';
import { ServicioTurnoDto } from './dto/servicio-turno.dto.js'; import { ServicioTurnoDto } from './dto/servicio-turno.dto.js';
import { UpdateServicioTurnoDto } from './dto/update-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 { WhereCondition } from '../../common/types/query-builder.types.js';
import { EstadoServicio } from '../../common/enums/estados.enum.js'; import { EstadoServicio } from '../../common/enums/estados.enum.js';
import { SERVICIO_TURNO_FIND_WHITELIST } from './servicio-turno.constants.js'; import { SERVICIO_TURNO_FIND_WHITELIST } from './servicio-turno.constants.js';
@ -25,15 +28,14 @@ export class ServicioTurnoService {
const servicio = await this.servicioRepository.findOneBy({ const servicio = await this.servicioRepository.findOneBy({
idServicio: servicioTurnoDto.idServicio, idServicio: servicioTurnoDto.idServicio,
}); });
if (!servicio) { if (!servicio || servicio.estado === EstadoServicio.Eliminado) {
serviceResult.message = 'No existe el servicio.'; serviceResult.message = servicio
return serviceResult; ? 'El servicio está eliminado.'
} : 'No existe el servicio.';
if (servicio.estado !== EstadoServicio.Programado) {
serviceResult.message =
'Solo se pueden asignar turnos a servicios en estado Programado.';
return serviceResult; 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 entity = this.servicioTurnoRepository.create(servicioTurnoDto);
const result = await this.servicioTurnoRepository.save(entity); const result = await this.servicioTurnoRepository.save(entity);
@ -49,7 +51,9 @@ export class ServicioTurnoService {
async findOne(idServicioTurno: string): Promise<ServiceResult> { async findOne(idServicioTurno: string): Promise<ServiceResult> {
const serviceResult = defaultServiceResult(); const serviceResult = defaultServiceResult();
const result = await this.servicioTurnoRepository.findOneBy({ idServicioTurno }); const result = await this.servicioTurnoRepository.findOneBy({
idServicioTurno,
});
if (result) { if (result) {
serviceResult.boolean = true; serviceResult.boolean = true;
@ -73,7 +77,8 @@ export class ServicioTurnoService {
const serviceResult = defaultServiceResult(); const serviceResult = defaultServiceResult();
try { try {
let query = this.servicioTurnoRepository.createQueryBuilder('servicioTurno'); let query =
this.servicioTurnoRepository.createQueryBuilder('servicioTurno');
whereConditions.forEach((condition, index) => { whereConditions.forEach((condition, index) => {
const { attribute, value, operator = '=' } = condition; const { attribute, value, operator = '=' } = condition;
@ -98,7 +103,10 @@ export class ServicioTurnoService {
throw new Error(`Atributo de orden no permitido: ${orderByAttribute}`); 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 totalRegistros = await query.getCount();
const skip = (offset - 1) * limit; const skip = (offset - 1) * limit;

View file

@ -1,16 +1,26 @@
import { ApiProperty } from '@nestjs/swagger'; 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'; import { EstadoServicio } from '../../../common/enums/estados.enum.js';
export class CambiarEstadoServicioDto { export class CambiarEstadoServicioDto {
@ApiProperty({ @ApiProperty({
enum: EstadoServicio, enum: EstadoServicio,
description: description:
'Matriz normal: Programado→Publicado/Cancelado; Publicado→EnCurso/Cancelado; ' + 'Multi-equipo: estado de servicio_equipo (por defecto todos los ' +
'EnCurso→Finalizado/Cancelado. SuperAdmin/Developer pueden elegir cualquier ' + 'equipos del alcance del usuario; `idEquipo` acota a uno). Sin ' +
'estado salvo el actual (corrección de errores).', 'equipos: máquina clásica del servicio. Publicar solo SuperAdmin/Dev; ' +
'Líder solo EnCurso/Finalizado de sus equipos.',
}) })
@IsEnum(EstadoServicio) @IsEnum(EstadoServicio)
@IsNotEmpty() @IsNotEmpty()
estado: EstadoServicio; estado: EstadoServicio;
@ApiProperty({
required: false,
description:
'Id de equipo convocado; si falta, aplica al alcance del usuario.',
})
@IsString()
@IsOptional()
idEquipo?: string;
} }

View file

@ -21,16 +21,12 @@ export class Servicio {
@Column({ type: 'double precision', nullable: true }) @Column({ type: 'double precision', nullable: true })
lng?: number | null; 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). * Solo se usa cuando el servicio NO tiene equipos convocados (extraordinario
* Se genera al publicar el servicio; el líder lo ve en el detalle. * 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 }) @Column({ type: 'varchar', nullable: true })
pinMarcado?: string | null; estado?: EstadoServicio | null;
} }

View file

@ -5,7 +5,7 @@ export const SERVICIO_FIND_WHITELIST = [
'estado', '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[]> = { export const SERVICIO_TRANSICIONES: Record<string, string[]> = {
Programado: ['Publicado', 'Cancelado'], Programado: ['Publicado', 'Cancelado'],
Publicado: ['EnCurso', 'Cancelado'], Publicado: ['EnCurso', 'Cancelado'],
@ -13,3 +13,26 @@ export const SERVICIO_TRANSICIONES: Record<string, string[]> = {
Finalizado: [], Finalizado: [],
Cancelado: [], 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'],
};

View file

@ -226,6 +226,7 @@ export class ServicioController {
idServicio, idServicio,
dto, dto,
user, user,
dto.idEquipo,
); );
if (result.boolean) { if (result.boolean) {
@ -247,11 +248,102 @@ export class ServicioController {
return apiResult; 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') @Post(':idServicio/pin')
@Autorizacion(AutorizacionEnum.SuperAdmin) @Autorizacion(AutorizacionEnum.SuperAdmin)
async regenerarPin( async regenerarPin(
@Req() req: AuthRequest, @Req() req: AuthRequest,
@Param('idServicio') idServicio: string, @Param('idServicio') idServicio: string,
@Body() body?: { idEquipo?: string },
): Promise<ApiResult> { ): Promise<ApiResult> {
const apiResult = defaultApiResult( const apiResult = defaultApiResult(
routeServicio.regenerarPin.title, routeServicio.regenerarPin.title,
@ -266,7 +358,10 @@ export class ServicioController {
return apiResult; return apiResult;
} }
const result = await this.servicioService.regenerarPin(idServicio); const result = await this.servicioService.regenerarPin(
idServicio,
body?.idEquipo,
);
if (result.boolean) { if (result.boolean) {
apiResult.status = 'correct'; apiResult.status = 'correct';

View file

@ -17,7 +17,15 @@ export const routeServicio = {
}, },
cambiarEstado: { cambiarEstado: {
route: '[PATCH].../v1/servicios/:idServicio/estado', 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: { remove: {
route: '[DELETE].../v1/servicios/:idServicio', route: '[DELETE].../v1/servicios/:idServicio',

File diff suppressed because it is too large Load diff

View file

@ -2,6 +2,7 @@ import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { SolicitudApoyo } from './entities/solicitud-apoyo.entity.js'; import { SolicitudApoyo } from './entities/solicitud-apoyo.entity.js';
import { Servicio } from '../servicio/entities/servicio.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 { Asistencia } from '../asistencia/entities/asistencia.entity.js';
import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js'; import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js';
import { Persona } from '../persona/entities/persona.entity.js'; import { Persona } from '../persona/entities/persona.entity.js';
@ -13,6 +14,7 @@ import { SolicitudApoyoController } from './solicitud-apoyo.controller.js';
TypeOrmModule.forFeature([ TypeOrmModule.forFeature([
SolicitudApoyo, SolicitudApoyo,
Servicio, Servicio,
ServicioEquipo,
Asistencia, Asistencia,
EquipoPersona, EquipoPersona,
Persona, Persona,

View file

@ -3,11 +3,18 @@ import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm'; import { Repository } from 'typeorm';
import { SolicitudApoyo } from './entities/solicitud-apoyo.entity.js'; import { SolicitudApoyo } from './entities/solicitud-apoyo.entity.js';
import { Servicio } from '../servicio/entities/servicio.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 { Asistencia } from '../asistencia/entities/asistencia.entity.js';
import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js'; import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js';
import { Persona } from '../persona/entities/persona.entity.js'; import { Persona } from '../persona/entities/persona.entity.js';
import { SolicitudApoyoDto, UpdateSolicitudApoyoDto } from './dto/solicitud-apoyo.dto.js'; import {
import { defaultServiceResult, ServiceResult } from '../../common/interfaces/service.result.js'; 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 { WhereCondition } from '../../common/types/query-builder.types.js';
import { import {
EstadoAsistencia, EstadoAsistencia,
@ -19,7 +26,11 @@ import {
import { TipoAsistencia } from '../../common/enums/tipos.enum.js'; import { TipoAsistencia } from '../../common/enums/tipos.enum.js';
import { Rol } from '../../common/enums/rol.enum.js'; import { Rol } from '../../common/enums/rol.enum.js';
import { SOLICITUD_APOYO_FIND_WHITELIST } from './solicitud-apoyo.constants.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() @Injectable()
export class SolicitudApoyoService { export class SolicitudApoyoService {
@ -28,6 +39,8 @@ export class SolicitudApoyoService {
private solicitudApoyoRepository: Repository<SolicitudApoyo>, private solicitudApoyoRepository: Repository<SolicitudApoyo>,
@InjectRepository(Servicio) @InjectRepository(Servicio)
private servicioRepository: Repository<Servicio>, private servicioRepository: Repository<Servicio>,
@InjectRepository(ServicioEquipo)
private servicioEquipoRepository: Repository<ServicioEquipo>,
@InjectRepository(Asistencia) @InjectRepository(Asistencia)
private asistenciaRepository: Repository<Asistencia>, private asistenciaRepository: Repository<Asistencia>,
@InjectRepository(EquipoPersona) @InjectRepository(EquipoPersona)
@ -48,14 +61,24 @@ export class SolicitudApoyoService {
serviceResult.message = 'No existe el servicio.'; serviceResult.message = 'No existe el servicio.';
return serviceResult; return serviceResult;
} }
if (servicio.estado !== EstadoServicio.Publicado) { // El estado vivo es el del EQUIPO solicitante en este servicio.
serviceResult.message = 'Solo se puede solicitar apoyo en servicio Publicado.'; 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; return serviceResult;
} }
if (!isDeveloper(user)) { if (!isDeveloper(user)) {
if (user.rol !== Rol.Lider) { 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; return serviceResult;
} }
const esLider = await this.equipoPersonaRepository.findOneBy({ const esLider = await this.equipoPersonaRepository.findOneBy({
@ -64,7 +87,8 @@ export class SolicitudApoyoService {
estado: EstadoMiembro.Activo, estado: EstadoMiembro.Activo,
}); });
if (!esLider) { 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; return serviceResult;
} }
} }
@ -88,10 +112,15 @@ export class SolicitudApoyoService {
return serviceResult; return serviceResult;
} }
async findOne(idSolicitudApoyo: string, user: AuthUser): Promise<ServiceResult> { async findOne(
idSolicitudApoyo: string,
user: AuthUser,
): Promise<ServiceResult> {
const serviceResult = defaultServiceResult(); const serviceResult = defaultServiceResult();
const result = await this.solicitudApoyoRepository.findOneBy({ idSolicitudApoyo }); const result = await this.solicitudApoyoRepository.findOneBy({
idSolicitudApoyo,
});
if (!result) { if (!result) {
serviceResult.message = 'No existe la solicitud de apoyo.'; serviceResult.message = 'No existe la solicitud de apoyo.';
return serviceResult; return serviceResult;
@ -122,7 +151,8 @@ export class SolicitudApoyoService {
const serviceResult = defaultServiceResult(); const serviceResult = defaultServiceResult();
try { try {
let query = this.solicitudApoyoRepository.createQueryBuilder('solicitud_apoyo'); let query =
this.solicitudApoyoRepository.createQueryBuilder('solicitud_apoyo');
whereConditions.forEach((condition, index) => { whereConditions.forEach((condition, index) => {
const { attribute, value, operator = '=' } = condition; const { attribute, value, operator = '=' } = condition;
@ -155,7 +185,10 @@ export class SolicitudApoyoService {
throw new Error(`Atributo de orden no permitido: ${orderByAttribute}`); 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 totalRegistros = await query.getCount();
const skip = (offset - 1) * limit; const skip = (offset - 1) * limit;
@ -180,7 +213,9 @@ export class SolicitudApoyoService {
): Promise<ServiceResult> { ): Promise<ServiceResult> {
const serviceResult = defaultServiceResult(); const serviceResult = defaultServiceResult();
const existente = await this.solicitudApoyoRepository.findOneBy({ idSolicitudApoyo }); const existente = await this.solicitudApoyoRepository.findOneBy({
idSolicitudApoyo,
});
if (!existente) { if (!existente) {
serviceResult.message = 'No se encontró la solicitud de apoyo.'; serviceResult.message = 'No se encontró la solicitud de apoyo.';
return serviceResult; return serviceResult;
@ -192,7 +227,8 @@ export class SolicitudApoyoService {
} }
const clean: Partial<SolicitudApoyo> = {}; 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 (dto.motivo !== undefined) clean.motivo = dto.motivo;
if (Object.keys(clean).length === 0) { if (Object.keys(clean).length === 0) {
@ -200,7 +236,10 @@ export class SolicitudApoyoService {
return serviceResult; return serviceResult;
} }
const result = await this.solicitudApoyoRepository.update(idSolicitudApoyo, clean); const result = await this.solicitudApoyoRepository.update(
idSolicitudApoyo,
clean,
);
serviceResult.boolean = result.affected === 1; serviceResult.boolean = result.affected === 1;
serviceResult.message = 'Solicitud de apoyo actualizada.'; serviceResult.message = 'Solicitud de apoyo actualizada.';
@ -212,10 +251,15 @@ export class SolicitudApoyoService {
/** /**
* Aceptar apoyo: elegibilidad + cupo atómico + fila Asistencia Apoyo. * 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 serviceResult = defaultServiceResult();
const solicitud = await this.solicitudApoyoRepository.findOneBy({ idSolicitudApoyo }); const solicitud = await this.solicitudApoyoRepository.findOneBy({
idSolicitudApoyo,
});
if (!solicitud) { if (!solicitud) {
serviceResult.message = 'No existe la solicitud de apoyo.'; serviceResult.message = 'No existe la solicitud de apoyo.';
return serviceResult; return serviceResult;
@ -232,7 +276,9 @@ export class SolicitudApoyoService {
} }
const solicitante = user.idPersona; 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) { if (!persona || persona.estado !== EstadoGeneral.Activo) {
serviceResult.message = 'La persona no existe o no está activa.'; serviceResult.message = 'La persona no existe o no está activa.';
return serviceResult; return serviceResult;
@ -243,13 +289,16 @@ export class SolicitudApoyoService {
} }
// no puede ser del equipo que pidió apoyo // no puede ser del equipo que pidió apoyo
const esDelEquipoSolicitante = await this.equipoPersonaRepository.findOneBy({ const esDelEquipoSolicitante = await this.equipoPersonaRepository.findOneBy(
idPersona: solicitante, {
idEquipo: solicitud.idEquipo, idPersona: solicitante,
estado: EstadoMiembro.Activo, idEquipo: solicitud.idEquipo,
}); estado: EstadoMiembro.Activo,
},
);
if (esDelEquipoSolicitante) { if (esDelEquipoSolicitante) {
serviceResult.message = 'No puede apoyar: pertenece al equipo que solicitó.'; serviceResult.message =
'No puede apoyar: pertenece al equipo que solicitó.';
return serviceResult; return serviceResult;
} }
@ -276,7 +325,8 @@ export class SolicitudApoyoService {
idPersona: solicitante, idPersona: solicitante,
}); });
if (yaAsistio) { 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; return serviceResult;
} }
@ -301,7 +351,10 @@ export class SolicitudApoyoService {
.execute(); .execute();
if (upd.affected === 0) { 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, { await manager.insert(Asistencia, {
@ -324,12 +377,16 @@ export class SolicitudApoyoService {
return serviceResult; return serviceResult;
} }
async cancelar(idSolicitudApoyo: string, user: AuthUser): Promise<ServiceResult> { async cancelar(
idSolicitudApoyo: string,
user: AuthUser,
): Promise<ServiceResult> {
const serviceResult = defaultServiceResult(); const serviceResult = defaultServiceResult();
const puedeAdmin = isDeveloper(user) || isSuperAdmin(user); const puedeAdmin = isDeveloper(user) || isSuperAdmin(user);
if (!puedeAdmin) { if (!puedeAdmin) {
serviceResult.message = 'Solo SuperAdmin/Developer pueden cancelar convocatorias.'; serviceResult.message =
'Solo SuperAdmin/Developer pueden cancelar convocatorias.';
return serviceResult; return serviceResult;
} }
@ -349,7 +406,8 @@ export class SolicitudApoyoService {
} }
private async puedeVer(user: AuthUser, s: SolicitudApoyo): Promise<boolean> { 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 (s.solicitadoPor === user.idPersona) return true;
if (user.rol === Rol.Lider || user.rol === Rol.Estaca) { if (user.rol === Rol.Lider || user.rol === Rol.Estaca) {
const m = await this.equipoPersonaRepository.findOneBy({ const m = await this.equipoPersonaRepository.findOneBy({

View file

@ -1,5 +1,11 @@
import { ApiProperty } from '@nestjs/swagger'; 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 { TipoTurno } from '../../../common/enums/tipos.enum.js';
import { EstadoGeneral } from '../../../common/enums/estados.enum.js'; import { EstadoGeneral } from '../../../common/enums/estados.enum.js';
@ -24,6 +30,20 @@ export class TurnoDto {
@IsNotEmpty() @IsNotEmpty()
horaFin: string; 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 }) @ApiProperty({ enum: EstadoGeneral, required: false })
@IsEnum(EstadoGeneral) @IsEnum(EstadoGeneral)
@IsOptional() @IsOptional()

View file

@ -21,6 +21,13 @@ export class Turno {
@Column({ type: 'varchar' }) @Column({ type: 'varchar' })
horaFin: string; 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({ @Column({
type: 'varchar', type: 'varchar',
default: EstadoGeneral.Activo, default: EstadoGeneral.Activo,

File diff suppressed because one or more lines are too long