app-min-ser-nest/src/modules/auth/auth.service.ts
2026-11-01 21:03:30 -04:00

396 lines
13 KiB
TypeScript
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { Injectable, Logger } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Persona } from '../persona/entities/persona.entity.js';
import { CodigoOtp } from '../codigo-otp/entities/codigo-otp.entity.js';
import { HashService } from '../../common/services/hash.service.js';
import { TokenService } from '../../common/services/token.service.js';
import { OpenwaService } from '../../common/services/openwa.service.js';
import {
defaultServiceResult,
ServiceResult,
} from '../../common/interfaces/service.result.js';
import { EstadoGeneral } from '../../common/enums/estados.enum.js';
import { EnviarOtpDto, LoginDto, UpdatePerfilDto } from './dto/auth.dto.js';
const OTP_EXPIRATION_MINUTES = 2;
const OTP_MAX_INTENTS = 3;
/** Cache en memoria del OTP vigente (para reenviar el MISMO código). */
type OtpCacheEntry = {
codigo: string;
expiraEn: number;
};
@Injectable()
export class AuthService {
private readonly logger = new Logger(AuthService.name);
private readonly otpCache = new Map<string, OtpCacheEntry>();
constructor(
@InjectRepository(Persona)
private personaRepository: Repository<Persona>,
@InjectRepository(CodigoOtp)
private codigoOtpRepository: Repository<CodigoOtp>,
private hashService: HashService,
private tokenService: TokenService,
private openwaService: OpenwaService,
) {}
async enviarOtp(dto: EnviarOtpDto, isResend = false): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const persona = await this.personaRepository.findOneBy({
codPais: dto.codPais,
whatsapp: dto.whatsapp,
});
if (!persona) {
serviceResult.message =
'No se encontró una cuenta con ese número. Contacte a su líder para el pre-registro.';
return serviceResult;
}
if (
persona.estado !== EstadoGeneral.Activo &&
persona.estado !== EstadoGeneral.Inhabilitado
) {
serviceResult.message =
'La cuenta no está activa. Contacte a su líder o administrador.';
return serviceResult;
}
// Invalidar OTPs ya caducados
await this.codigoOtpRepository
.createQueryBuilder()
.update(CodigoOtp)
.set({ usado: true })
.where('"idPersona" = :idPersona', { idPersona: persona.idPersona })
.andWhere('usado = :usado', { usado: false })
.andWhere('"fecExpiracion" < now()')
.execute();
// ¿Existe OTP vigente (sin usar y sin caducar)?
const activo = await this.codigoOtpRepository
.createQueryBuilder('otp')
.where('otp."idPersona" = :idPersona', { idPersona: persona.idPersona })
.andWhere('otp.usado = :usado', { usado: false })
.andWhere('otp."fecExpiracion" > now()')
.orderBy('otp."fecCreacion"', 'DESC')
.getOne();
if (activo) {
const cache = this.otpCache.get(persona.idPersona);
const cacheVigente = !!cache && cache.expiraEn > Date.now();
// Reenviar: si tenemos el código en memoria, manda EL MISMO (no crea otro)
if (isResend && cacheVigente) {
try {
await this.sendOtpViaOpenwa(persona, cache.codigo);
} catch (error) {
this.logger.error(`Error OpenWA: ${error.message}`);
serviceResult.message = `No se pudo reenviar el código: ${error.message}`;
return serviceResult;
}
serviceResult.boolean = true;
serviceResult.message =
'Código reenviado por WhatsApp (el mismo código anterior).';
serviceResult.number = 1;
// Solo en dev: idPersona + código. En producción no se expone nada.
serviceResult.object =
process.env.NODE_ENV !== 'production'
? { idPersona: persona.idPersona, codigoDebug: cache.codigo }
: null;
return serviceResult;
}
// Ya hay código vigente → NO crear otro
const expira = new Date(activo.fecExpiracion);
const hhmm = `${String(expira.getHours()).padStart(2, '0')}:${String(
expira.getMinutes(),
).padStart(2, '0')}`;
serviceResult.message = `Ya existe un código activo válido hasta las ${hhmm}. Úselo o espere a que expire para solicitar uno nuevo.`;
return serviceResult;
}
// Sin código vigente → crear uno nuevo
const codigo = this.generateOtpCode();
const codigoHash = await this.hashService.hashText(codigo);
const fecCreacion = new Date();
const fecExpiracion = new Date(
fecCreacion.getTime() + OTP_EXPIRATION_MINUTES * 60_000,
);
await this.codigoOtpRepository.manager.transaction(async (manager) => {
await manager
.createQueryBuilder()
.update(CodigoOtp)
.set({ usado: true })
.where('"idPersona" = :idPersona', { idPersona: persona.idPersona })
.andWhere('usado = :usado', { usado: false })
.execute();
await manager.save(CodigoOtp, {
idPersona: persona.idPersona,
codigoHash,
intentosFallidos: 0,
fecCreacion,
fecExpiracion,
usado: false,
});
});
this.otpCache.set(persona.idPersona, {
codigo,
expiraEn: fecExpiracion.getTime(),
});
try {
await this.sendOtpViaOpenwa(persona, codigo);
} catch (error) {
this.logger.error(`Error OpenWA: ${error.message}`);
serviceResult.message = `No se pudo enviar el código por WhatsApp: ${error.message}`;
return serviceResult;
}
serviceResult.boolean = true;
serviceResult.message = 'Código enviado por WhatsApp.';
serviceResult.number = 1;
// Solo en dev: idPersona + código. En producción no se expone nada.
serviceResult.object =
process.env.NODE_ENV !== 'production'
? { idPersona: persona.idPersona, codigoDebug: codigo }
: null;
return serviceResult;
}
async login(dto: LoginDto): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const persona = await this.personaRepository.findOneBy({
codPais: dto.codPais,
whatsapp: dto.whatsapp,
});
if (!persona) {
serviceResult.message = 'Credenciales inválidas.';
return serviceResult;
}
if (
persona.estado !== EstadoGeneral.Activo &&
persona.estado !== EstadoGeneral.Inhabilitado
) {
serviceResult.message = 'La cuenta no está activa.';
return serviceResult;
}
const otp = await this.codigoOtpRepository
.createQueryBuilder('otp')
.where('otp."idPersona" = :idPersona', { idPersona: persona.idPersona })
.andWhere('otp.usado = :usado', { usado: false })
.andWhere('otp."fecExpiracion" > now()')
.orderBy('otp."fecCreacion"', 'DESC')
.getOne();
if (!otp) {
serviceResult.message = 'No hay un código activo. Solicite uno nuevo.';
return serviceResult;
}
if (otp.intentosFallidos >= OTP_MAX_INTENTS) {
await this.codigoOtpRepository.update(otp.idOtp, { usado: true });
this.otpCache.delete(persona.idPersona);
serviceResult.message =
'Código bloqueado por seguridad. Solicite uno nuevo.';
return serviceResult;
}
const match = await this.hashService.compareTexts(
dto.codigo,
otp.codigoHash,
);
if (!match) {
const intentos = otp.intentosFallidos + 1;
const payload: Partial<CodigoOtp> =
intentos >= OTP_MAX_INTENTS
? { intentosFallidos: intentos, usado: true }
: { intentosFallidos: intentos };
await this.codigoOtpRepository.update(otp.idOtp, payload);
if (intentos >= OTP_MAX_INTENTS) {
this.otpCache.delete(persona.idPersona);
}
serviceResult.message = `Código incorrecto. ${Math.max(
0,
OTP_MAX_INTENTS - intentos,
)} intento(s) restante(s).`;
return serviceResult;
}
await this.codigoOtpRepository.update(otp.idOtp, { usado: true });
this.otpCache.delete(persona.idPersona);
const updates: Partial<Persona> = { ultConexion: new Date() };
// Plataforma del login (tanda presencia 2026-11-01): Android/iOS/Web.
const plataforma = dto.platform?.trim();
if (plataforma) {
updates.platform = plataforma.slice(0, 20);
}
if (!persona.verificado) {
updates.verificado = true;
}
await this.personaRepository.update(persona.idPersona, updates);
const token = this.tokenService.generateToken({
idPersona: persona.idPersona,
rol: persona.rol,
autorizacion: persona.autorizacion,
});
serviceResult.boolean = true;
serviceResult.message = 'Sesión iniciada correctamente.';
serviceResult.number = 1;
serviceResult.object = {
token,
persona: {
idPersona: persona.idPersona,
nombres: persona.nombres,
apellidos: persona.apellidos,
rol: persona.rol,
autorizacion: persona.autorizacion,
},
};
return serviceResult;
}
/**
* Emite un JWT nuevo con `rol`/`autorizacion` leídos de la DB.
* El usuario NO cierra sesión: solo se renuevan los permisos del token
* cuando cambiaron en la base (flujo de refresh de la Fase 2).
*/
async refrescar(idPersona: string): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const persona = await this.personaRepository.findOneBy({ idPersona });
if (!persona) {
serviceResult.message = 'No existe la persona.';
return serviceResult;
}
if (
persona.estado !== EstadoGeneral.Activo &&
persona.estado !== EstadoGeneral.Inhabilitado
) {
serviceResult.message = 'La cuenta no está activa.';
return serviceResult;
}
const token = this.tokenService.generateToken({
idPersona: persona.idPersona,
rol: persona.rol,
autorizacion: persona.autorizacion,
});
serviceResult.boolean = true;
serviceResult.message = 'Sesión renovada.';
serviceResult.number = 1;
serviceResult.object = {
token,
rol: persona.rol,
autorizacion: persona.autorizacion,
};
return serviceResult;
}
async getPerfil(
idPersona: string,
platform?: string,
): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const persona = await this.personaRepository.findOneBy({ idPersona });
if (!persona) {
serviceResult.message = 'No existe la persona.';
return serviceResult;
}
// Plataforma del arranque/revalidación (tanda presencia 2026-11-01):
// el splash la manda en cada apertura con `?platform=` y solo se
// escribe si cambió (con token de 30d el login no refresca a diario).
const nueva = platform?.trim().slice(0, 20);
if (nueva && nueva !== persona.platform) {
await this.personaRepository.update(idPersona, { platform: nueva });
persona.platform = nueva;
}
serviceResult.boolean = true;
serviceResult.message = 'Perfil obtenido.';
serviceResult.number = 1;
serviceResult.object = persona;
return serviceResult;
}
async updatePerfil(
idPersona: string,
dto: UpdatePerfilDto,
): Promise<ServiceResult> {
const serviceResult = defaultServiceResult();
const clean: Partial<Persona> = {};
if (dto.nombres !== undefined) clean.nombres = dto.nombres;
if (dto.apellidos !== undefined) clean.apellidos = dto.apellidos;
if (dto.photoUrl !== undefined) clean.photoUrl = dto.photoUrl;
if (dto.fecNac !== undefined) clean.fecNac = dto.fecNac;
if (dto.ci !== undefined) clean.ci = dto.ci;
if (dto.complemento !== undefined) clean.complemento = dto.complemento;
if (Object.keys(clean).length === 0) {
serviceResult.message = 'No hay campos para actualizar.';
return serviceResult;
}
const result = await this.personaRepository.update(idPersona, clean);
serviceResult.boolean = result.affected === 1;
serviceResult.message =
result.affected === 1
? 'Perfil actualizado correctamente.'
: 'No se encontró la persona.';
serviceResult.number = result.affected || 0;
return serviceResult;
}
private generateOtpCode(): string {
return String(Math.floor(1000 + Math.random() * 9000));
}
private async sendOtpViaOpenwa(
persona: Persona,
codigo: string,
): Promise<void> {
// Fuente única: OPENWA_SESSION_ID del .env (pool coma-separado con
// rotación round-robin; la BD ya no participa).
const sessionId = this.openwaService.resolveSessionId();
if (!sessionId) {
throw new Error(
'No hay sessionId de OpenWA: definí OPENWA_SESSION_ID en .env (un id o una lista coma-separada).',
);
}
const chatId = this.openwaService.buildChatId(
persona.codPais,
persona.whatsapp,
);
const text = `*Tu código de acceso es:* ${codigo}.\n🏛️ *_Ministerio Ser Ekklesia_*\n\n🔐 \n⏳ *Caduca en ${OTP_EXPIRATION_MINUTES} minutos.*\n\n🙏 No compartas este código con nadie.`;
await this.openwaService.sendText(chatId, text, sessionId);
}
}