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"
env_file:
- .env
environment:
TZ: America/La_Paz
restart: unless-stopped
networks:
- 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;
}
// modificacion.txt e.i: Líder/Estaca (cualquier autorización) y Servidor
// con Dev/SuperAdmin. Developer bypasea el guard; el service revalida
// por fila (Dev/SuperAdmin o Líder/Estaca con membresía).
@Patch(':idAsistencia')
@Roles(Rol.Lider)
@Autorizacion(AutorizacionEnum.SuperAdmin)
@Roles(Rol.Lider, Rol.Estaca, Rol.Servidor)
async update(
@Req() req: AuthRequest,
@Param('idAsistencia') idAsistencia: string,
@ -244,8 +246,10 @@ export class AsistenciaController {
return apiResult;
}
// modificacion.txt e.i: Permiso/Falta para Líder o Estaca del equipo
// (Developer bypasea; el service valida la membresía de la fila).
@Post(':idAsistencia/estado')
@Roles(Rol.Lider)
@Roles(Rol.Lider, Rol.Estaca)
async setEstado(
@Req() req: AuthRequest,
@Param('idAsistencia') idAsistencia: string,

View file

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

View file

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

View file

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

View file

@ -1,5 +1,17 @@
import { ApiProperty } from '@nestjs/swagger';
import { IsNotEmpty, IsNumber, IsOptional, IsString } from 'class-validator';
import {
IsInt,
IsNotEmpty,
IsNumber,
IsOptional,
IsString,
Matches,
Min,
} from 'class-validator';
import {
ZONA_HORA_DEFAULT,
ZONA_HORA_RE,
} from '../../../common/utils/zona-horaria.js';
export class ConfiguracionDto {
@ApiProperty()
@ -17,6 +29,32 @@ export class ConfiguracionDto {
@IsNotEmpty()
distancia: number;
@ApiProperty({
required: false,
default: 0,
description:
'Minutos de tolerancia tras la hora límite de ingreso (Atrasado).',
example: 10,
})
@IsOptional()
@IsInt()
@Min(0)
tolerancia?: number;
@ApiProperty({
required: false,
default: ZONA_HORA_DEFAULT,
description:
'Offset UTC de la organización para calcular Atrasados (±HH:MM).',
example: '-04:00',
})
@IsOptional()
@IsString()
@Matches(ZONA_HORA_RE, {
message: 'Zona horaria inválida (use ±HH:MM, p. ej. -04:00).',
})
zonaHoraria?: string;
@ApiProperty({ required: false, description: 'SessionId de OpenWA' })
@IsString()
@IsOptional()

View file

@ -14,6 +14,20 @@ export class Configuracion {
@Column('double precision')
distancia: number;
/**
* Minutos de tolerancia tras la hora límite de ingreso de la primera
* reunión del servicio (0 = sin gracia). Ver `turno.limiteIngreso`.
*/
@Column({ type: 'int', default: 0 })
tolerancia: number;
/**
* Offset UTC de la organización (`±HH:MM`, p. ej. `-04:00` Bolivia) para
* calcular Atrasado/Presente sin depender de la zona del servidor.
*/
@Column({ type: 'varchar', default: '-04:00' })
zonaHoraria: string;
/** SessionId de OpenWA (Easy API). Si es null se usa OPENWA_SESSION_ID de .env */
@Column({ type: 'varchar', nullable: true })
openwaSessionId?: string | null;

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 type { Response } from 'express';
import { diskStorage } from 'multer';
import { existsSync, mkdirSync } from 'fs';
import { basename, extname, join } from 'path';
import { Autorizacion } from '../../common/decorators/autorizacion.decorator.js';
import { Autorizacion as AutorizacionEnum } from '../../common/enums/rol.enum.js';
import {
ApiResult,
defaultApiResult,
} from '../../common/interfaces/api.result.js';
import type { AuthRequest } from '../../common/utils/auth-user.js';
import { getAuthUser } from '../../common/utils/auth-user.js';
import { PurgaDto } from './dto/purga.dto.js';
import {
BackupDto,
EliminarBackupDto,
RestaurarDto,
} from './dto/backup.dto.js';
import { MantenimientoService } from './mantenimiento.service.js';
import { BackupService } from './backup.service.js';
import { routeMantenimiento } from './mantenimiento.router.js';
function dirBackups(): string {
const dir = join(process.cwd(), 'backups');
if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
return dir;
}
@ApiTags('mantenimiento')
@ApiBearerAuth()
@Controller('mantenimiento')
export class MantenimientoController {
constructor(private readonly mantenimientoService: MantenimientoService) {}
constructor(
private readonly mantenimientoService: MantenimientoService,
private readonly backupService: BackupService,
) {}
/// Borrado físico total por categoría: dryRun cuenta; ejecutar exige
/// `confirmacion === 'ELIMINAR'`.
@ -59,4 +93,348 @@ export class MantenimientoController {
return apiResult;
}
/// Cuántas personas están `Inhabilitado` (marca de reportes).
@Get('personas-inhabilitadas')
@Autorizacion(AutorizacionEnum.Developer)
async contarInhabilitadas(): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeMantenimiento.contarInhabilitadas.title,
routeMantenimiento.contarInhabilitadas.route,
);
try {
const result = await this.mantenimientoService.contarInhabilitadas();
apiResult.status = 'correct';
apiResult.code = HttpStatus.OK;
apiResult.message = result.message;
apiResult.boolean = true;
apiResult.rows = result.number;
apiResult.data = [result.object];
} catch (error) {
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
apiResult.message = error.message;
}
return apiResult;
}
/// `Inhabilitado` → `Activo` en todas las personas (corrige reportes).
@Post('activar-personas')
@Autorizacion(AutorizacionEnum.Developer)
async activarPersonas(): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeMantenimiento.activarInhabilitadas.title,
routeMantenimiento.activarInhabilitadas.route,
);
try {
const result = await this.mantenimientoService.activarInhabilitadas();
apiResult.status = 'correct';
apiResult.code = HttpStatus.OK;
apiResult.message = result.message;
apiResult.boolean = true;
apiResult.rows = result.number;
apiResult.data = [result.object];
} catch (error) {
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
apiResult.message = error.message;
}
return apiResult;
}
/// Mayúscula inicial por palabra en nombres/apellidos de todas las personas.
@Post('normalizar-nombres')
@Autorizacion(AutorizacionEnum.Developer)
async normalizarNombres(): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeMantenimiento.normalizarNombres.title,
routeMantenimiento.normalizarNombres.route,
);
try {
const result = await this.mantenimientoService.normalizarNombres();
apiResult.status = 'correct';
apiResult.code = HttpStatus.OK;
apiResult.message = result.message;
apiResult.boolean = true;
apiResult.rows = result.number;
apiResult.data = [result.object];
} catch (error) {
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
apiResult.message = error.message;
}
return apiResult;
}
/// Genera un `.sql` (completo = pg_dump; selectivo = INSERTs por categoría).
@Post('backup')
@Autorizacion(AutorizacionEnum.Developer)
async generarBackup(
@Req() req: AuthRequest,
@Body() dto: BackupDto,
): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeMantenimiento.backupGenerar.title,
routeMantenimiento.backupGenerar.route,
);
try {
const user = getAuthUser(req);
if (!user) {
apiResult.code = HttpStatus.UNAUTHORIZED;
apiResult.message = 'Token inválido.';
return apiResult;
}
if (dto.tipo === 'selectivo' && !dto.categorias?.length) {
apiResult.code = HttpStatus.BAD_REQUEST;
apiResult.message =
'Elegí al menos una categoría para el respaldo selectivo.';
return apiResult;
}
const result = await this.backupService.generar(
dto.tipo,
dto.categorias,
user.idPersona,
);
if (result.boolean) {
apiResult.status = 'correct';
apiResult.code = HttpStatus.OK;
apiResult.message = result.message;
apiResult.boolean = true;
apiResult.rows = result.number;
apiResult.data = [result.object];
} else {
apiResult.code = HttpStatus.BAD_REQUEST;
apiResult.message = result.message;
if (result.object) apiResult.data = [result.object];
}
} catch (error) {
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
apiResult.message = error.message;
}
return apiResult;
}
/// Lista de respaldos (fecha, tipo, tamaño, estado, origen).
@Get('backup')
@Autorizacion(AutorizacionEnum.Developer)
async listarBackups(): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeMantenimiento.backupListar.title,
routeMantenimiento.backupListar.route,
);
try {
const result = await this.backupService.listar();
apiResult.status = 'correct';
apiResult.code = HttpStatus.OK;
apiResult.message = result.message;
apiResult.boolean = true;
apiResult.rows = result.number;
// Envelope de lista: un solo objeto `{ items: [...] }` en data[0]
// (ApiClient solo expone el primer elemento como `objeto`).
apiResult.data = [{ items: result.data ?? [] }];
} catch (error) {
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
apiResult.message = error.message;
}
return apiResult;
}
/// Descarga autenticada del `.sql` (no está en `/uploads` estático).
@Get('backup/:idBackup/descarga')
@Autorizacion(AutorizacionEnum.Developer)
async descargarBackup(
@Param('idBackup') idBackup: string,
@Res() res: Response,
): Promise<void> {
try {
const archivo = await this.backupService.leerArchivo(idBackup);
if (!archivo) {
res.status(HttpStatus.NOT_FOUND).json({
title: routeMantenimiento.backupDescarga.title,
route: routeMantenimiento.backupDescarga.route,
status: '',
code: 404,
message: 'Respaldo no encontrado.',
boolean: false,
rows: 0,
data: [],
});
return;
}
res
.status(HttpStatus.OK)
.set({
'Content-Type': 'application/sql; charset=utf-8',
'Content-Disposition': `attachment; filename="${archivo.nombre}"`,
'Content-Length': String(archivo.bytes.length),
})
.send(archivo.bytes);
} catch (error) {
res.status(error.status ?? HttpStatus.INTERNAL_SERVER_ERROR).json({
title: routeMantenimiento.backupDescarga.title,
route: routeMantenimiento.backupDescarga.route,
status: '',
code: error.status ?? 500,
message: error.message,
boolean: false,
rows: 0,
data: [],
});
}
}
/// Restaura con `psql -f`; exige `confirmacion: 'RESTAURAR'`.
@Post('backup/:idBackup/restaurar')
@Autorizacion(AutorizacionEnum.Developer)
async restaurarBackup(
@Param('idBackup') idBackup: string,
@Body() dto: RestaurarDto,
): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeMantenimiento.backupRestaurar.title,
routeMantenimiento.backupRestaurar.route,
);
try {
if (dto.confirmacion !== 'RESTAURAR') {
apiResult.code = HttpStatus.BAD_REQUEST;
apiResult.message =
'Confirmación incorrecta: escribí RESTAURAR para restaurar.';
return apiResult;
}
const result = await this.backupService.restaurar(idBackup);
if (result.boolean) {
apiResult.status = 'correct';
apiResult.code = HttpStatus.OK;
apiResult.message = result.message;
apiResult.boolean = true;
apiResult.rows = result.number;
apiResult.data = [result.object];
} else {
apiResult.code = HttpStatus.BAD_REQUEST;
apiResult.message = result.message;
}
} catch (error) {
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
apiResult.message = error.message;
}
return apiResult;
}
/// Elimina el archivo `.sql` y la fila; exige `confirmacion: 'ELIMINAR'`.
@Delete('backup/:idBackup')
@Autorizacion(AutorizacionEnum.Developer)
async eliminarBackup(
@Param('idBackup') idBackup: string,
@Body() dto: EliminarBackupDto,
): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeMantenimiento.backupEliminar.title,
routeMantenimiento.backupEliminar.route,
);
try {
if (dto?.confirmacion !== 'ELIMINAR') {
apiResult.code = HttpStatus.BAD_REQUEST;
apiResult.message =
'Confirmación incorrecta: escribí ELIMINAR para borrar el respaldo.';
return apiResult;
}
const result = await this.backupService.eliminar(idBackup);
if (result.boolean) {
apiResult.status = 'correct';
apiResult.code = HttpStatus.OK;
apiResult.message = result.message;
apiResult.boolean = true;
apiResult.rows = result.number;
apiResult.data = [result.object];
} else {
apiResult.code = HttpStatus.BAD_REQUEST;
apiResult.message = result.message;
}
} catch (error) {
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
apiResult.message = error.message;
}
return apiResult;
}
/// Sube un `.sql` desde otro server (multipart campo `archivo`).
@Post('backup/cargar')
@Autorizacion(AutorizacionEnum.Developer)
@UseInterceptors(
FileInterceptor('archivo', {
storage: diskStorage({
destination: (_req, _file, callback) => {
callback(null, dirBackups());
},
filename: (_req, file, callback) => {
const ext = extname(file.originalname).toLowerCase() || '.sql';
callback(
null,
`tmp-${Date.now()}-${basename(file.originalname, extname(file.originalname)).replace(/[^\w.-]+/g, '_')}${ext}`,
);
},
}),
limits: { fileSize: 512 * 1024 * 1024 },
fileFilter: (_req, file, callback) => {
if (!file.originalname.toLowerCase().endsWith('.sql')) {
callback(
new Error('El archivo debe tener extensión .sql.'),
false,
);
return;
}
callback(null, true);
},
}),
)
async cargarBackup(
@Req() req: AuthRequest,
@UploadedFile() file?: Express.Multer.File,
): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeMantenimiento.backupCargar.title,
routeMantenimiento.backupCargar.route,
);
try {
const user = getAuthUser(req);
if (!user) {
apiResult.code = HttpStatus.UNAUTHORIZED;
apiResult.message = 'Token inválido.';
return apiResult;
}
if (!file?.path || !file.filename) {
apiResult.code = HttpStatus.BAD_REQUEST;
apiResult.message = 'No se recibió el archivo .sql (campo "archivo").';
return apiResult;
}
const { readFile, unlink } = await import('fs/promises');
const buffer = await readFile(file.path);
const result = await this.backupService.cargar(
buffer,
file.originalname,
user.idPersona,
);
await unlink(file.path).catch(() => undefined);
if (result.boolean) {
apiResult.status = 'correct';
apiResult.code = HttpStatus.OK;
apiResult.message = result.message;
apiResult.boolean = true;
apiResult.rows = result.number;
apiResult.data = [result.object];
} else {
apiResult.code = HttpStatus.BAD_REQUEST;
apiResult.message = result.message;
}
} catch (error) {
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
apiResult.message = error.message;
}
return apiResult;
}
}

View file

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

View file

@ -3,4 +3,40 @@ export const routeMantenimiento = {
route: '[POST].../v1/mantenimiento/purga',
title: 'Purga de datos (Developer)',
},
backupGenerar: {
route: '[POST].../v1/mantenimiento/backup',
title: 'Generar respaldo .sql (Developer)',
},
backupListar: {
route: '[GET].../v1/mantenimiento/backup',
title: 'Listar respaldos (Developer)',
},
backupDescarga: {
route: '[GET].../v1/mantenimiento/backup/:idBackup/descarga',
title: 'Descargar respaldo .sql (Developer)',
},
backupRestaurar: {
route: '[POST].../v1/mantenimiento/backup/:idBackup/restaurar',
title: 'Restaurar respaldo .sql (Developer)',
},
backupCargar: {
route: '[POST].../v1/mantenimiento/backup/cargar',
title: 'Cargar respaldo .sql (Developer)',
},
backupEliminar: {
route: '[DELETE].../v1/mantenimiento/backup/:idBackup',
title: 'Eliminar respaldo .sql (Developer)',
},
contarInhabilitadas: {
route: '[GET].../v1/mantenimiento/personas-inhabilitadas',
title: 'Contar personas inhabilitadas (Developer)',
},
activarInhabilitadas: {
route: '[POST].../v1/mantenimiento/activar-personas',
title: 'Reactivar personas inhabilitadas (Developer)',
},
normalizarNombres: {
route: '[POST].../v1/mantenimiento/normalizar-nombres',
title: 'Normalizar nombres/apellidos (Developer)',
},
};

View file

@ -13,6 +13,7 @@ import { ServicioTurno } from '../servicio-turno/entities/servicio-turno.entity.
import { Servicio } from '../servicio/entities/servicio.entity.js';
import { SolicitudApoyo } from '../solicitud-apoyo/entities/solicitud-apoyo.entity.js';
import { Turno } from '../turno/entities/turno.entity.js';
import { EstadoGeneral } from '../../common/enums/estados.enum.js';
import {
defaultServiceResult,
ServiceResult,
@ -194,4 +195,96 @@ export class MantenimientoService {
return serviceResult;
}
/// Personas con `estado = Inhabilitado` (marca por reporte).
async contarInhabilitadas(): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const n = await this.personaRepo.count({
where: { estado: EstadoGeneral.Inhabilitado },
});
serviceResult.boolean = true;
serviceResult.message = `${n} persona(s) inhabilitada(s).`;
serviceResult.number = n;
serviceResult.object = { inhabilitadas: n };
return serviceResult;
}
/**
* Pasa `Inhabilitado` → `Activo` en todas las personas (corrige la
* marca errónea de la subrutina de reportes; no toca Inactivo/Eliminado).
*/
async activarInhabilitadas(): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const n = await this.personaRepo.count({
where: { estado: EstadoGeneral.Inhabilitado },
});
if (n === 0) {
serviceResult.boolean = true;
serviceResult.message = 'No hay personas inhabilitadas.';
serviceResult.number = 0;
serviceResult.object = { activadas: 0 };
return serviceResult;
}
await this.personaRepo
.createQueryBuilder()
.update(Persona)
.set({ estado: EstadoGeneral.Activo })
.where('estado = :estado', { estado: EstadoGeneral.Inhabilitado })
.execute();
serviceResult.boolean = true;
serviceResult.message = `${n} persona(s) reactivada(s) (Inhabilitado → Activo).`;
serviceResult.number = n;
serviceResult.object = { activadas: n };
return serviceResult;
}
/**
* `nombres`/`apellidos` a mayúscula inicial por palabra
* (`DIEGO LLUSCO` → `Diego Llusco`). Solo actualiza las filas que cambian.
*/
async normalizarNombres(): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const filas = await this.personaRepo.find({
select: { idPersona: true, nombres: true, apellidos: true },
});
let cambios = 0;
for (const p of filas) {
const nombres = this.capitalizarPalabras(p.nombres ?? '');
const apellidos = this.capitalizarPalabras(p.apellidos ?? '');
if (nombres === p.nombres && apellidos === p.apellidos) continue;
await this.personaRepo.update(
{ idPersona: p.idPersona },
{ nombres, apellidos },
);
cambios++;
}
serviceResult.boolean = true;
serviceResult.message =
cambios === 0
? 'Todos los nombres ya tienen mayúscula inicial.'
: `${cambios} persona(s) con nombres/apellidos normalizados.`;
serviceResult.number = cambios;
serviceResult.object = { normalizadas: cambios };
return serviceResult;
}
/// Mayúscula inicial de cada palabra; el resto en minúscula.
private capitalizarPalabras(texto: string): string {
return texto
.split(/(\s+)/)
.map((parte) => {
if (/^\s+$/.test(parte) || parte === '') return parte;
const min = parte.toLowerCase();
const primera = min.match(/\p{L}/u);
if (!primera) return min;
const i = min.search(/\p{L}/u);
return min.slice(0, i) + min[i].toUpperCase() + min.slice(i + 1);
})
.join('');
}
}

View file

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

View file

@ -4,14 +4,15 @@ import { Repository } from 'typeorm';
import { EventsService } from '../../common/services/events.service.js';
import { Reemplazo } from './entities/reemplazo.entity.js';
import { Servicio } from '../servicio/entities/servicio.entity.js';
import { ServicioEquipo } from '../servicio-equipo/entities/servicio-equipo.entity.js';
import { Asistencia } from '../asistencia/entities/asistencia.entity.js';
import { EquipoPersona } from '../equipo-persona/entities/equipo-persona.entity.js';
import { Persona } from '../persona/entities/persona.entity.js';
import { AceptarReemplazoDto, ReemplazoDto } from './dto/reemplazo.dto.js';
import {
AceptarReemplazoDto,
ReemplazoDto,
} from './dto/reemplazo.dto.js';
import { defaultServiceResult, ServiceResult } from '../../common/interfaces/service.result.js';
defaultServiceResult,
ServiceResult,
} from '../../common/interfaces/service.result.js';
import { WhereCondition } from '../../common/types/query-builder.types.js';
import {
EstadoAsistencia,
@ -23,7 +24,11 @@ import {
import { TipoAsistencia } from '../../common/enums/tipos.enum.js';
import { Rol } from '../../common/enums/rol.enum.js';
import { REMPLAZO_FIND_WHITELIST } from './reemplazo.constants.js';
import { AuthUser, isDeveloper, isSuperAdmin } from '../../common/utils/auth-user.js';
import {
AuthUser,
isDeveloper,
isSuperAdmin,
} from '../../common/utils/auth-user.js';
@Injectable()
export class ReemplazoService {
@ -34,6 +39,8 @@ export class ReemplazoService {
private reemplazoRepository: Repository<Reemplazo>,
@InjectRepository(Servicio)
private servicioRepository: Repository<Servicio>,
@InjectRepository(ServicioEquipo)
private servicioEquipoRepository: Repository<ServicioEquipo>,
@InjectRepository(Asistencia)
private asistenciaRepository: Repository<Asistencia>,
@InjectRepository(EquipoPersona)
@ -59,10 +66,6 @@ export class ReemplazoService {
serviceResult.message = 'No existe el servicio.';
return serviceResult;
}
if (servicio.estado !== EstadoServicio.Publicado) {
serviceResult.message = 'Solo se puede solicitar reemplazo en servicio Publicado.';
return serviceResult;
}
const membresia = await this.equipoPersonaRepository.findOneBy({
idPersona: idPersonaTitular,
@ -73,12 +76,28 @@ export class ReemplazoService {
return serviceResult;
}
// El estado vivo es el del EQUIPO del titular en este servicio.
const se = await this.servicioEquipoRepository.findOneBy({
idServicio: dto.idServicio,
idEquipo: membresia.idEquipo,
});
const estadoEquipo = se?.estado;
const estadoVivo = se
? estadoEquipo
: ((servicio.estado as EstadoServicio | null) ?? null);
if (estadoVivo !== EstadoServicio.Publicado) {
serviceResult.message =
'Solo se puede solicitar reemplazo cuando el equipo está Publicado.';
return serviceResult;
}
const asistencia = await this.asistenciaRepository.findOneBy({
idServicio: dto.idServicio,
idPersona: idPersonaTitular,
});
if (!asistencia) {
serviceResult.message = 'No existe fila de asistencia para este titular en el servicio.';
serviceResult.message =
'No existe fila de asistencia para este titular en el servicio.';
return serviceResult;
}
if (asistencia.tipo !== TipoAsistencia.Titular) {
@ -96,7 +115,8 @@ export class ReemplazoService {
estado: EstadoConvocatoria.Abierto,
});
if (abierto) {
serviceResult.message = 'Ya existe un reemplazo Abierto para este titular.';
serviceResult.message =
'Ya existe un reemplazo Abierto para este titular.';
return serviceResult;
}
@ -106,7 +126,8 @@ export class ReemplazoService {
estado: EstadoConvocatoria.Cubierto,
});
if (cubierto) {
serviceResult.message = 'Ya existe un reemplazo Cubierto para este titular.';
serviceResult.message =
'Ya existe un reemplazo Cubierto para este titular.';
return serviceResult;
}
@ -130,7 +151,7 @@ export class ReemplazoService {
const elegibles = await this.personaRepository
.createQueryBuilder('p')
.where('p.estado = :e', { e: EstadoGeneral.Activo })
.andWhere("p.rol != :admin", { admin: Rol.Admin })
.andWhere('p.rol != :admin', { admin: Rol.Admin })
.andWhere('p."idPersona" != :titular', { titular: idPersonaTitular })
.getMany();
const ids = elegibles.map((p) => p.idPersona);
@ -142,7 +163,9 @@ export class ReemplazoService {
data: { idReemplazo: result.idReemplazo, idServicio: dto.idServicio },
});
} catch (error) {
this.logger.warn(`No se pudo emitir evento reemplazo: ${error.message}`);
this.logger.warn(
`No se pudo emitir evento reemplazo: ${error.message}`,
);
}
}
@ -283,7 +306,11 @@ export class ReemplazoService {
/**
* Aceptación atómica + cambio de tipo de asistencia a 'Reemplazo'.
*/
async aceptar(idReemplazo: string, dto: AceptarReemplazoDto, user: AuthUser): Promise<ServiceResult> {
async aceptar(
idReemplazo: string,
dto: AceptarReemplazoDto,
user: AuthUser,
): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const reemplazo = await this.reemplazoRepository.findOneBy({ idReemplazo });
@ -298,7 +325,9 @@ export class ReemplazoService {
}
const solicitante = dto.idPersonaReemplazo ?? user.idPersona;
const persona = await this.personaRepository.findOneBy({ idPersona: solicitante });
const persona = await this.personaRepository.findOneBy({
idPersona: solicitante,
});
if (!persona || persona.estado !== EstadoGeneral.Activo) {
serviceResult.message = 'El reemplazante no existe o no está activo.';
return serviceResult;
@ -369,7 +398,9 @@ export class ReemplazoService {
idReemplazo,
})
.where('"idServicio" = :idServicio', { idServicio: reemplazo.idServicio })
.andWhere('"idPersona" = :idTitular', { idTitular: reemplazo.idPersonaTitular })
.andWhere('"idPersona" = :idTitular', {
idTitular: reemplazo.idPersonaTitular,
})
.execute();
serviceResult.boolean = true;
@ -386,7 +417,9 @@ export class ReemplazoService {
data: { idReemplazo },
});
} catch (error) {
this.logger.warn(`No se pudo emitir evento reemplazo cubierto: ${error.message}`);
this.logger.warn(
`No se pudo emitir evento reemplazo cubierto: ${error.message}`,
);
}
}
@ -416,17 +449,23 @@ export class ReemplazoService {
const servicio = await this.servicioRepository.findOneBy({
idServicio: reemplazo.idServicio,
});
const se = await this.servicioEquipoRepository.findOneBy({
idServicio: reemplazo.idServicio,
idEquipo: reemplazo.idEquipo,
});
const estadoVivo = se
? se.estado
: ((servicio?.estado as EstadoServicio | null) ?? null);
const servicioIniciado =
servicio?.estado === EstadoServicio.EnCurso ||
servicio?.estado === EstadoServicio.Finalizado;
estadoVivo === EstadoServicio.EnCurso ||
estadoVivo === EstadoServicio.Finalizado;
const esTitular = user.idPersona === reemplazo.idPersonaTitular;
const puedeAdmin = isDeveloper(user) || isSuperAdmin(user);
if (esTitular && !puedeAdmin) {
if (servicioIniciado) {
serviceResult.message =
'No puede cancelar: el servicio ya inició.';
serviceResult.message = 'No puede cancelar: el servicio ya inició.';
return serviceResult;
}
@ -442,8 +481,12 @@ export class ReemplazoService {
idReemplazo: null,
tipo: TipoAsistencia.Titular,
})
.where('"idServicio" = :idServicio', { idServicio: reemplazo.idServicio })
.andWhere('"idPersona" = :idTitular', { idTitular: reemplazo.idPersonaTitular })
.where('"idServicio" = :idServicio', {
idServicio: reemplazo.idServicio,
})
.andWhere('"idPersona" = :idTitular', {
idTitular: reemplazo.idPersonaTitular,
})
.execute();
});
@ -475,8 +518,12 @@ export class ReemplazoService {
}
private async puedeVer(user: AuthUser, r: Reemplazo): Promise<boolean> {
if (isDeveloper(user) || isSuperAdmin(user) || user.rol === Rol.Admin) return true;
if (r.idPersonaTitular === user.idPersona || r.idPersonaReemplazo === user.idPersona) {
if (isDeveloper(user) || isSuperAdmin(user) || user.rol === Rol.Admin)
return true;
if (
r.idPersonaTitular === user.idPersona ||
r.idPersonaReemplazo === user.idPersona
) {
return true;
}
if (user.rol === Rol.Lider || user.rol === Rol.Estaca) {

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

View file

@ -1,4 +1,5 @@
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
import { EstadoServicio } from '../../../common/enums/estados.enum.js';
@Entity('servicio_equipo')
export class ServicioEquipo {
@ -13,4 +14,21 @@ export class ServicioEquipo {
@Column({ type: 'uuid' })
asignadoPor: string;
/**
* Ciclo de vida de ESTE equipo en el servicio (multi-equipo: cada líder
* maneja el suyo). Dev/SuperAdmin pueden mover cualquier fila.
*/
@Column({
type: 'varchar',
default: EstadoServicio.Programado,
})
estado: EstadoServicio;
/**
* PIN de 6 dígitos del equipo para marcar (PIN/QR). Se genera al publicar
* esta fila (`estado = Publicado`).
*/
@Column({ type: 'varchar', nullable: true })
pinMarcado?: string | null;
}

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

View file

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

View file

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

View file

@ -21,16 +21,12 @@ export class Servicio {
@Column({ type: 'double precision', nullable: true })
lng?: number | null;
@Column({
type: 'varchar',
default: EstadoServicio.Programado,
})
estado: EstadoServicio;
/**
* PIN de 6 dígitos para marcar asistencia (PIN tecleado o escaneado en QR).
* Se genera al publicar el servicio; el líder lo ve en el detalle.
* Solo se usa cuando el servicio NO tiene equipos convocados (extraordinario
* con turnos + apoyos). Si hay filas en `servicio_equipo`, el ciclo de vida
* (y el PIN) viven en cada fila de equipo; aquí queda `null`.
* `Eliminado` sigue siendo el borrado lógico del servicio completo.
*/
@Column({ type: 'varchar', nullable: true })
pinMarcado?: string | null;
estado?: EstadoServicio | null;
}

View file

@ -5,7 +5,7 @@ export const SERVICIO_FIND_WHITELIST = [
'estado',
];
/** Matriz de transiciones de estado del servicio */
/** Matriz de transiciones de estado del servicio (solo sin equipos). */
export const SERVICIO_TRANSICIONES: Record<string, string[]> = {
Programado: ['Publicado', 'Cancelado'],
Publicado: ['EnCurso', 'Cancelado'],
@ -13,3 +13,26 @@ export const SERVICIO_TRANSICIONES: Record<string, string[]> = {
Finalizado: [],
Cancelado: [],
};
/**
* Matriz de transiciones de `servicio_equipo.estado` para Dev/SuperAdmin
* (relajada: cualquier destino salvo el actual, incl. Eliminado).
*/
export const SERVICIO_EQUIPO_TRANSICIONES_SUPER: Record<string, string[]> = {
Programado: ['Publicado', 'Cancelado', 'Eliminado'],
Publicado: ['EnCurso', 'Finalizado', 'Cancelado', 'Eliminado'],
EnCurso: ['Finalizado', 'Cancelado', 'Eliminado'],
// Reabrir solo Dev/Super para que un líder pueda volver a cerrar.
Finalizado: ['EnCurso', 'Cancelado', 'Eliminado'],
Cancelado: ['Programado', 'Publicado'],
Eliminado: [],
};
/**
* Transiciones que un Líder (cualquier autorización) puede hacer en SUS
* equipos: publicar es de SuperAdmin/Dev; el líder inicia y finaliza.
*/
export const SERVICIO_EQUIPO_TRANSICIONES_LIDER: Record<string, string[]> = {
Publicado: ['EnCurso', 'Finalizado'],
EnCurso: ['Finalizado'],
};

View file

@ -226,6 +226,7 @@ export class ServicioController {
idServicio,
dto,
user,
dto.idEquipo,
);
if (result.boolean) {
@ -247,11 +248,102 @@ export class ServicioController {
return apiResult;
}
/** Estado de UN equipo del servicio (multi-equipo). */
@Patch(':idServicio/equipo/:idEquipo/estado')
@Autorizacion(AutorizacionEnum.SuperAdmin, AutorizacionEnum.Usuario)
async cambiarEstadoEquipo(
@Req() req: AuthRequest,
@Param('idServicio') idServicio: string,
@Param('idEquipo') idEquipo: string,
@Body() dto: CambiarEstadoServicioDto,
): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeServicio.cambiarEstadoEquipo.title,
routeServicio.cambiarEstadoEquipo.route,
);
try {
const user = getAuthUser(req);
if (!user) {
apiResult.code = HttpStatus.UNAUTHORIZED;
apiResult.message = 'Token inválido.';
return apiResult;
}
const result = await this.servicioService.cambiarEstado(
idServicio,
dto,
user,
idEquipo,
);
if (result.boolean) {
apiResult.status = 'correct';
apiResult.code = HttpStatus.OK;
apiResult.message = result.message;
apiResult.boolean = true;
apiResult.rows = result.number;
apiResult.data = result.object ? [result.object] : [];
} else {
apiResult.code = HttpStatus.BAD_REQUEST;
apiResult.message = result.message;
}
} catch (error) {
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
apiResult.message = error.message;
}
return apiResult;
}
/**
* Batch: `body.idEquipo` opcional — sin él, Dev/Super aplican a todos
* los equipos del servicio y el Líder a los suyos.
*/
@Patch(':idServicio/equipos/estado')
@Autorizacion(AutorizacionEnum.SuperAdmin, AutorizacionEnum.Usuario)
async cambiarEstadoEquipos(
@Req() req: AuthRequest,
@Param('idServicio') idServicio: string,
@Body() dto: CambiarEstadoServicioDto,
): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeServicio.cambiarEstadoEquipos.title,
routeServicio.cambiarEstadoEquipos.route,
);
try {
const user = getAuthUser(req);
if (!user) {
apiResult.code = HttpStatus.UNAUTHORIZED;
apiResult.message = 'Token inválido.';
return apiResult;
}
const result = await this.servicioService.cambiarEstado(
idServicio,
dto,
user,
dto.idEquipo,
);
if (result.boolean) {
apiResult.status = 'correct';
apiResult.code = HttpStatus.OK;
apiResult.message = result.message;
apiResult.boolean = true;
apiResult.rows = result.number;
apiResult.data = result.object ? [result.object] : [];
} else {
apiResult.code = HttpStatus.BAD_REQUEST;
apiResult.message = result.message;
}
} catch (error) {
apiResult.code = error.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
apiResult.message = error.message;
}
return apiResult;
}
@Post(':idServicio/pin')
@Autorizacion(AutorizacionEnum.SuperAdmin)
async regenerarPin(
@Req() req: AuthRequest,
@Param('idServicio') idServicio: string,
@Body() body?: { idEquipo?: string },
): Promise<ApiResult> {
const apiResult = defaultApiResult(
routeServicio.regenerarPin.title,
@ -266,7 +358,10 @@ export class ServicioController {
return apiResult;
}
const result = await this.servicioService.regenerarPin(idServicio);
const result = await this.servicioService.regenerarPin(
idServicio,
body?.idEquipo,
);
if (result.boolean) {
apiResult.status = 'correct';

View file

@ -17,7 +17,15 @@ export const routeServicio = {
},
cambiarEstado: {
route: '[PATCH].../v1/servicios/:idServicio/estado',
title: 'Cambiar Estado Servicio',
title: 'Cambiar Estado Servicio (sin equipos o batch por alcance)',
},
cambiarEstadoEquipo: {
route: '[PATCH].../v1/servicios/:idServicio/equipo/:idEquipo/estado',
title: 'Cambiar Estado de un equipo del servicio',
},
cambiarEstadoEquipos: {
route: '[PATCH].../v1/servicios/:idServicio/equipos/estado',
title: 'Cambiar Estado de equipos del servicio (batch)',
},
remove: {
route: '[DELETE].../v1/servicios/:idServicio',

File diff suppressed because it is too large Load diff

View file

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

View file

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

View file

@ -1,5 +1,11 @@
import { ApiProperty } from '@nestjs/swagger';
import { IsEnum, IsNotEmpty, IsOptional, IsString } from 'class-validator';
import {
IsEnum,
IsNotEmpty,
IsOptional,
IsString,
Matches,
} from 'class-validator';
import { TipoTurno } from '../../../common/enums/tipos.enum.js';
import { EstadoGeneral } from '../../../common/enums/estados.enum.js';
@ -24,6 +30,20 @@ export class TurnoDto {
@IsNotEmpty()
horaFin: string;
@ApiProperty({
required: false,
description:
'Hora límite de ingreso HH:MM (opcional). Vacía = se usa horaInicio. ' +
'Con configuracion.tolerancia define el Atrasado.',
example: '06:30',
})
@IsOptional()
@IsString()
@Matches(/^([01]\d|2[0-3]):[0-5]\d$/, {
message: 'limiteIngreso debe tener formato HH:MM.',
})
limiteIngreso?: string | null;
@ApiProperty({ enum: EstadoGeneral, required: false })
@IsEnum(EstadoGeneral)
@IsOptional()

View file

@ -21,6 +21,13 @@ export class Turno {
@Column({ type: 'varchar' })
horaFin: string;
/**
* Hora límite para llegar a tiempo (HH:MM). Si es null se usa `horaInicio`.
* El `Atrasado` se decide con esta hora + `configuracion.tolerancia`.
*/
@Column({ type: 'varchar', nullable: true })
limiteIngreso?: string | null;
@Column({
type: 'varchar',
default: EstadoGeneral.Activo,

File diff suppressed because one or more lines are too long