396 lines
13 KiB
TypeScript
396 lines
13 KiB
TypeScript
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);
|
||
}
|
||
}
|