Rama temporal para ver si el bottest la puede deployar en demo

auth/auth.controller.ts

@@ -167,6 +167,13 @@ export async function updateUser(documento, nombre, apellido, password) {
     );
 }
 
+export async function updateEmailUser(documento, email) {
+    return await AuthUsers.findOneAndUpdate(
+        { usuario: documento },
+        { email }
+    );
+}
+
 export async function updateOrganizacion(usuario, idOrg) {
     const org = usuario.user.organizaciones.find(organizacion => idOrg.toString() === organizacion._id.toString());
     org.lastLogin = new Date();
@@ -206,10 +213,13 @@ export async function setValidationTokenAndNotify(username) {
     try {
         const usuario = await AuthUsers.findOne({ usuario: username });
         if (usuario && usuario.tipo === 'temporal' && usuario.email) {
-            usuario.validationToken = new mongoose.Types.ObjectId().toHexString();
-            usuario.audit(userScheduler);
-            await usuario.save();
-
+            if (!usuario.validationToken || usuario.validationTokenExpiration < new Date()) {
+                // Si no tiene un token de validación o esta vencido, se genera uno nuevo
+                usuario.validationToken = new mongoose.Types.ObjectId().toHexString();
+                usuario.validationTokenExpiration = new Date(Date.now() + 72 * 60 * 60 * 1000); // Expira en 72 horas
+                usuario.audit(userScheduler);
+                await usuario.save();
+            }
             const extras: any = {
                 titulo: 'Recuperación de contraseña',
                 usuario,
@@ -253,38 +263,42 @@ export async function sendOtpAndNotify(username): Promise<any> {
         const usuario = await AuthUsers.findOne({ usuario: username });
 
         // Se mantiene la validación para usuarios temporales con email
-        if (usuario && usuario.tipo === 'temporal' && usuario.email) {
-            // Genera un código OTP de 6 dígitos
-            const otpCode = crypto.randomInt(100000, 999999).toString();
-
-            usuario.otp = {
-                code: otpCode,
-                expiresAt: new Date(Date.now() + 60 * 60 * 1000), // 10 minutos en milisegundos
-            };
-
-            usuario.audit(userScheduler);
-            await usuario.save();
-
-            const extras: any = {
-                titulo: 'Código de Verificación',
-                usuario,
-                otpCode,
-            };
-            const htmlToSend = await renderHTML('emails/otp-code.html', extras);
-
-            const options: MailOptions = {
-                from: enviarMail.auth.user,
-                to: usuario.email.toString(),
-                subject: 'Tu código de verificación',
-                text: '',
-                html: htmlToSend,
-                attachments: null,
-            };
-            await sendMail(options);
+        if (usuario) {
+            if (usuario.tipo === 'temporal' && usuario.email) {
+                // Genera un código OTP de 6 dígitos
+                const otpCode = crypto.randomInt(100000, 999999).toString();
+
+                usuario.otp = {
+                    code: otpCode,
+                    expiresAt: new Date(Date.now() + 60 * 60 * 1000), // 10 minutos en milisegundos
+                };
+
+                usuario.audit(userScheduler);
+                await usuario.save();
+
+                const extras: any = {
+                    titulo: 'Código de Verificación',
+                    usuario,
+                    otpCode,
+                };
+                const htmlToSend = await renderHTML('emails/otp-code.html', extras);
+
+                const options: MailOptions = {
+                    from: enviarMail.auth.user,
+                    to: usuario.email.toString(),
+                    subject: 'Tu código de verificación',
+                    text: '',
+                    html: htmlToSend,
+                    attachments: null,
+                };
+                await sendMail(options);
+            } else {
+                return null;
+            }
             return usuario;
         } else {
             // El usuario no existe o no es un usuario temporal con email
-            return null;
+            throw { tipo: 'cuentaInexistenteAndes' };
         }
     } catch (error) {
         throw error;
@@ -329,8 +343,9 @@ export async function validateOtpAndResetPassword(username, otpCode, newPassword
 export async function reset(token, password) {
     try {
         const usuario = await AuthUsers.findOne({ validationToken: token });
-        if (usuario) {
+        if (usuario && usuario.validationTokenExpiration > new Date()) {
             usuario.validationToken = null;
+            usuario.validationTokenExpiration = null;
             usuario.password = sha1Hash(password);
             usuario.audit(userScheduler);
             await usuario.save();
@@ -349,7 +364,7 @@ export async function updateUserPermisos(req) {
 
     const permisos = getPermisosByType(req.body.tipoPermisos);
 
-    if (permisos && permisos.length) {
+    if (permisos?.length) {
         const organizacionPermisos = user.organizaciones;
         if (organizacionPermisos && organizacionPermisos.length) {
             permisos.forEach(e => {

auth/routes/routes.ts

@@ -276,7 +276,10 @@ router.post('/sendOTPCode', async (req, res, next) => {
         } else {
             return next(403);
         }
-    } catch (error) {
+    } catch (error: any) {
+        if (error.tipo === 'cuentaInexistenteAndes') {
+            return res.json({ status: 'cuentaInexistenteAndes' });
+        }
         return next(error);
     }
 });

auth/schemas/authUsers.ts

@@ -28,6 +28,7 @@ export interface IAuthUsers {
     lastLogin: Date;
     tipo?: String;
     validationToken?: String;
+    validationTokenExpiration?: Date;
     email?: String;
     configuracion?: { [key: string]: any };
     disclaimers?: {

core/tm/controller/profesional.ts

@@ -5,8 +5,12 @@ import * as stream from 'stream';
 import { userScheduler } from '../../../config.private';
 import * as turno from '../../../modules/matriculaciones/schemas/turno';
 import { turnoSolicitado } from '../../../modules/matriculaciones/schemas/turnoSolicitado';
+import { makeFs } from '../schemas/imagenes';
 import { makeFsFirmaAdmin } from '../schemas/firmaAdmin';
 import { makeFsFirma } from '../schemas/firmaProf';
+import { makeFsFirmaOnline } from '../schemas/firmaRenovacionOnline';
+import { makeFsFirmaAdminOnline } from '../schemas/firmaAdminRenovacionOnline';
+import { makeFsImagenOnline } from '../schemas/imagenRenovacionOnline';
 import { Profesional } from '../schemas/profesional';
 import { Auth } from './../../../auth/auth.class';
 import { findUsersByUsername } from './../../../auth/auth.controller';
@@ -192,23 +196,49 @@ export async function saveFirma(data, admin = false) {
     const input = new stream.PassThrough();
     let firma;
     let metadataFind;
+    let metadataFindOnline;
     let metadataWrite;
 
-    if (admin) {
-        firma = makeFsFirmaAdmin();
-        metadataFind = { 'metadata.idSupervisor': data.idSupervisor };
-        metadataWrite = {
-            idSupervisor: data.idSupervisor,
-            administracion: data.nombreCompleto
-        };
+    if (data.option === 'renovacionOnline') {
+        if (admin) {
+            firma = makeFsFirmaAdminOnline();
+            metadataFind = {
+                'metadata.idProfesional': data.idProfesional,
+                'metadata.matricula': data.matricula
+            };
+            metadataWrite = {
+                idProfesional: data.idProfesional,
+                matricula: data.matricula
+            };
+        } else {
+            firma = makeFsFirmaOnline();
+
+            metadataFind = {
+                'metadata.idProfesional': data.idProfesional,
+                'metadata.matricula': data.matricula
+            };
+            metadataWrite = {
+                idProfesional: data.idProfesional,
+                matricula: data.matricula
+            };
+        }
     } else {
-        firma = makeFsFirma();
+
+        metadataFindOnline = {
+            'metadata.idProfesional': data.idProfesional,
+            'metadata.matricula': data.matricula
+        };
         metadataFind = { 'metadata.idProfesional': data.idProfesional };
         metadataWrite = { idProfesional: data.idProfesional };
+        if (admin) {
+            firma = makeFsFirmaAdmin();
+        } else {
+            firma = makeFsFirma();
+        }
     }
-
     // Remueve la firma anterior antes de insertar la nueva
     const fileFirma = await firma.findOne(metadataFind);
+
     if (fileFirma?._id) {
         await firma.unlink(fileFirma._id, (error) => { });
     }
@@ -231,6 +261,99 @@ export async function saveFirma(data, admin = false) {
     });
 }
 
+export async function deleteFirmaFotoTemporal(idProfesional, matricula, next) {
+
+    const metadataFind = {
+        'metadata.idProfesional': idProfesional,
+        'metadata.matricula': matricula
+    };
+
+    try {
+        const firma = makeFsFirmaOnline();
+
+        // Remueve la firma anterior antes de insertar la nueva
+        const fileFirma = await firma.findOne(metadataFind);
+        if (fileFirma?._id) {
+            await new Promise<void>((resolve, reject) => {
+                firma.unlink(fileFirma._id, (error) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve();
+                });
+            });
+        }
+
+        const imagen = makeFsImagenOnline();
+        // Remueve la imagen anterior antes de insertar la nueva
+        const fileImagen = await imagen.findOne(metadataFind);
+        if (fileImagen?._id) {
+            await new Promise<void>((resolve, reject) => {
+                imagen.unlink(fileImagen._id, (error) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve();
+                });
+            });
+        }
+    } catch (error) {
+        return next(error);
+    }
+
+}
+
+export async function saveImage(data) {
+
+    const _base64 = data.img;
+    const decoder = base64.decode();
+    const input = new stream.PassThrough();
+    let fotoProf;
+    let metadataFind;
+    let metadataFindOnline;
+    let metadataWrite;
+
+    if (data.option === 'renovacionOnline') {
+        fotoProf = makeFsImagenOnline();
+
+        metadataFind = {
+            'metadata.idProfesional': data.idProfesional,
+            'metadata.matricula': data.matricula
+        };
+        metadataWrite = {
+            idProfesional: data.idProfesional,
+            matricula: data.matricula
+        };
+    } else {
+        metadataFind = { 'metadata.idProfesional': data.idProfesional };
+        metadataWrite = { idProfesional: data.idProfesional };
+        fotoProf = makeFs();
+    }
+
+    const file = await fotoProf.findOne(metadataFind);
+
+    if (file?._id) {
+        await fotoProf.unlink(file._id, (error) => { });
+    }
+    // Inserta en la bd en files y chunks
+    return new Promise((resolve, reject) => {
+        fotoProf.writeFile(
+            {
+                filename: 'foto.png',
+                contentType: 'image/png',
+                metadata: metadataWrite
+            }, input.pipe(decoder),
+            (error, createdFile) => {
+                if (error) {
+                    reject(error);
+                }
+                resolve(createdFile);
+            }
+        );
+        input.end(_base64);
+    });
+}
+
 export async function filtrarProfesionalesPorPrestacion(profesionales, prestaciones, organizacionId) {
     const usuarios = await findUsersByUsername(profesionales.map(p => p.documento));