src/server.js

@@ -1,179 +1,224 @@
 const express = require('express');
-const cors = require('cors');
 const fetch = require('node-fetch');
+const ovh = require('ovh');
+require('dotenv').config();
 
-// Initialisation de l'application Express
 const app = express();
-const PORT = process.env.PORT || 8080;
-
-// Configuration CORS
-const corsOptions = {
-  origin: ['http://local.lecoffreio.4nkweb:3000', 'http://localhost:3000'],
-  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
-  allowedHeaders: ['Content-Type', 'Authorization']
-};
-
-app.use(cors(corsOptions));
 app.use(express.json());
 
-function getOfficeStatus(statusName) {
+const config = {
-  switch (statusName) {
+    // Configuration OVH
-    case 'Pourvu':
+    OVH_APP_KEY: process.env.OVH_APP_KEY,
-      return 'ACTIVATED';
+    OVH_APP_SECRET: process.env.OVH_APP_SECRET,
-    case 'Pourvu mais décédé':
+    OVH_CONSUMER_KEY: process.env.OVH_CONSUMER_KEY,
-      return 'ACTIVATED';
+    OVH_SMS_SERVICE_NAME: process.env.OVH_SMS_SERVICE_NAME,
-    case 'Sans titulaire':
+    
-      return 'ACTIVATED';
+    // Configuration SMS Factor
-    case 'Vacance':
+    SMS_FACTOR_TOKEN: process.env.SMS_FACTOR_TOKEN,
-      return 'ACTIVATED';
+    
-    case 'En activité':
+    PORT: process.env.PORT || 8080
-      return 'ACTIVATED';
+};
-    default:
-      return 'DESACTIVATED';
-  }
-}
 
-function getRole(roleName) {
+// Stockage temporaire des codes
-  switch (roleName) {
+const verificationCodes = new Map();
-    case 'Notaire titulaire':
-      return { name: 'admin', label: 'Administrateur' };
-    case 'Notaire associé':
-      return { name: 'admin', label: 'Administrateur' };
-    case 'Notaire salarié':
-      return { name: 'notary', label: 'Notaire' };
-    case 'Collaborateur':
-      return { name: 'notary', label: 'Notaire' };
-    case 'Suppléant':
-      return { name: 'notary', label: 'Notaire' };
-    case 'Administrateur':
-      return { name: 'admin', label: 'Administrateur' };
-    case 'Curateur':
-      return { name: 'notary', label: 'Notaire' };
-    default:
-      return { name: 'default', label: 'Défaut' };
-  }
-}
 
-function getCivility(civility) {
+// Service SMS
-  switch (civility) {
+class SmsService {
-    case 'Monsieur':
+    static generateCode() {
-      return 'MALE';
+        return Math.floor(100000 + Math.random() * 900000);
-    case 'Madame':
-      return 'FEMALE';
-    default:
-      return 'OTHERS';
-  }
-}
-
-app.get('/api/v1/health', (req, res) => {
-  res.json({ message: 'OK' });
-});
-
-app.post('/api/v1/idnot/user/:code', async (req, res) => {
-  const code = req.params.code;
-
-  try {
-    const params = {
-      client_id: 'B3CE56353EDB15A9',
-      client_secret: '3F733549E879878344B6C949B366BB5CDBB2DB5B7F7AB7EBBEBB0F0DD0776D1C',
-      redirect_uri: 'http://local.lecoffreio.4nkweb:3000/authorized-client',
-      grant_type: 'authorization_code',
-      code: code
-    };
-
-    const tokens = await (
-      await fetch('https://qual-connexion.idnot.fr/user/IdPOAuth2/token/idnot_idp_v1', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/x-www-form-urlencoded',
-        },
-        body: new URLSearchParams(params).toString()
-      })
-    ).json();
-
-    const jwt = tokens.id_token;
-    if (!jwt) {
-      console.error('jwt not defined');
-      return null;
     }
-    const payload = JSON.parse(Buffer.from(jwt.split('.')[1], 'base64').toString('utf8'));
 
-    const searchParams = new URLSearchParams({
+    // Service OVH
-      key: 'ba557f84-0bf6-4dbf-844f-df2767555e3e'
+    static sendSmsWithOvh(phoneNumber, message) {
-    });
+        return new Promise((resolve, reject) => {
+            const ovhClient = ovh({
+                appKey: config.OVH_APP_KEY,
+                appSecret: config.OVH_APP_SECRET,
+                consumerKey: config.OVH_CONSUMER_KEY
+            });
+
+            ovhClient.request('POST', `/sms/${config.OVH_SMS_SERVICE_NAME}/jobs`, {
+                message: message,
+                receivers: [phoneNumber],
+                senderForResponse: false,
+                sender: "not.IT Fact",
+                noStopClause: true
+            }, (error, result) => {
+                if (error) {
+                    console.error('Erreur OVH SMS:', error);
+                    resolve({ success: false, error: 'Échec de l\'envoi du SMS via OVH' });
+                } else {
+                    resolve({ success: true });
+                }
+            });
+        });
+    }
+
+    // Service SMS Factor
+    static async sendSmsWithSmsFactor(phoneNumber, message) {
+        try {
+            const url = new URL('https://api.smsfactor.com/send/simulate');
+            url.searchParams.append('to', phoneNumber);
+            url.searchParams.append('text', message);
+            url.searchParams.append('sender', 'LeCoffre');
+            url.searchParams.append('token', config.SMS_FACTOR_TOKEN);
+
+            const response = await fetch(url.toString());
+            
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+
+            return { success: true };
+        } catch (error) {
+            console.error('Erreur SMS Factor:', error);
+            return { success: false, error: 'Échec de l\'envoi du SMS via SMS Factor' };
+        }
+    }
+
+    // Méthode principale d'envoi
+    static async sendSms(phoneNumber, message) {
+        // Essai d'abord avec OVH
+        const ovhResult = await this.sendSmsWithOvh(phoneNumber, message);
+        
+        if (ovhResult.success) {
+            return ovhResult;
+        }
+
+        // Si OVH échoue, essai avec SMS Factor
+        console.log('OVH SMS failed, trying SMS Factor...');
+        return await this.sendSmsWithSmsFactor(phoneNumber, message);
+    }
+}
+
+// Middleware de validation
+const validatePhoneNumber = (req, res, next) => {
+    const { phoneNumber } = req.body;
+    
+    if (!phoneNumber) {
+        return res.status(400).json({
+            success: false,
+            message: 'Le numéro de téléphone est requis'
+        });
+    }
+
+    // Validation basique du format
+    const phoneRegex = /^\+?[1-9]\d{1,14}$/;
+    if (!phoneRegex.test(phoneNumber)) {
+        return res.status(400).json({
+            success: false,
+            message: 'Format de numéro de téléphone invalide'
+        });
+    }
+
+    next();
+};
+
+// Routes
+app.post('/api/send-verification', validatePhoneNumber, async (req, res) => {
+    const { phoneNumber } = req.body;
 
-    let userData;
     try {
-      userData = await (
+        // Vérifier si un code existe déjà et n'est pas expiré
-        await fetch(`https://qual-api.notaires.fr/annuaire/api/pp/v2/rattachements/${payload.profile_idn}?` + searchParams, {
+        const existingVerification = verificationCodes.get(phoneNumber);
-          method: 'GET'
+        if (existingVerification) {
-        })
+            const timeSinceLastSend = Date.now() - existingVerification.timestamp;
-      ).json();
+            if (timeSinceLastSend < 30000) { // 30 secondes
+                return res.status(429).json({
+                    success: false,
+                    message: 'Veuillez attendre 30 secondes avant de demander un nouveau code'
+                });
+            }
+        }
+
+        // Générer un nouveau code
+        const code = SmsService.generateCode();
+        
+        // Stocker le code
+        verificationCodes.set(phoneNumber, {
+            code,
+            timestamp: Date.now(),
+            attempts: 0
+        });
+
+        // Envoyer le SMS
+        const message = `Votre code de vérification LeCoffre est : ${code}`;
+        const result = await SmsService.sendSms(phoneNumber, message);
+
+        if (result.success) {
+            res.json({
+                success: true,
+                message: 'Code envoyé avec succès',
+            });
+        } else {
+            res.status(500).json({
+                success: false,
+                message: 'Échec de l\'envoi du SMS via les deux fournisseurs'
+            });
+        }
     } catch (error) {
-      console.error('Error fetching ' + `https://qual-api.notaires.fr/annuaire/api/pp/v2/rattachements/${payload.profile_idn}`, error);
+        console.error('Erreur:', error);
-      return null;
+        res.status(500).json({
+            success: false,
+            message: 'Erreur serveur lors de l\'envoi du code'
+        });
     }
-    if (!userData || !userData.statutDuRattachement || userData.entite.typeEntite.name !== 'office') {
-      console.error('User not attached to an office (May be a partner)');
-      return null;
-    }
-
-    let officeLocationData;
-    try {
-      officeLocationData = (await (
-        await fetch(`https://qual-api.notaires.fr/annuaire${userData.entite.locationsUrl}?` + searchParams,
-          {
-            method: 'GET'
-          })
-      ).json());
-    } catch (error) {
-      console.error('Error fetching' + `https://qual-api.notaires.fr/annuaire${userData.entite.locationsUrl}`, error);
-      return null;
-    }
-    if (!officeLocationData || !officeLocationData.result || officeLocationData.result.length === 0) {
-      console.error('Office location data not found');
-      return null;
-    }
-
-    const idnotUser = {
-      idNot: payload.sub,
-      office: {
-        idNot: payload.entity_idn,
-        name: userData.entite.denominationSociale ?? userData.entite.codeCrpcen,
-        crpcen: userData.entite.codeCrpcen,
-        office_status: getOfficeStatus(userData.entite.statutEntite.name),
-        address: {
-          address: officeLocationData.result[0].adrGeo4,
-          city: officeLocationData.result[0].adrGeoVille.split(' ')[0] ?? officeLocationData.result[0].adrGeoVille,
-          zip_code: Number(officeLocationData.result[0].adrGeoCodePostal)
-        },
-        status: 'ACTIVE'
-      },
-      role: getRole(userData.typeLien.name),
-      contact: {
-        first_name: userData.personne.prenom,
-        last_name: userData.personne.nomUsuel,
-        email: userData.mailRattachement,
-        phone_number: userData.numeroTelephone,
-        cell_phone_number: userData.numeroMobile ?? userData.numeroTelephone,
-        civility: getCivility(userData.personne.civilite)
-      }
-    };
-
-    if (!idnotUser.contact.email) {
-      console.error("User pro email empty");
-      return null;
-    }
-
-    res.json(idnotUser);
-  } catch (error) {
-    res.status(500).json({
-      error: 'Internal Server Error',
-      message: error.message
-    });
-  }
 });
 
-app.listen(PORT, () => {
+app.post('/api/verify-code', validatePhoneNumber, (req, res) => {
-  console.log(`Server is running on port ${PORT}`);
+    const { phoneNumber, code } = req.body;
+
+    if (!code) {
+        return res.status(400).json({
+            success: false,
+            message: 'Le code est requis'
+        });
+    }
+
+    const verification = verificationCodes.get(phoneNumber);
+
+    if (!verification) {
+        return res.status(400).json({
+            success: false,
+            message: 'Aucun code n\'a été envoyé à ce numéro'
+        });
+    }
+
+    // Vérifier si le code n'a pas expiré (5 minutes)
+    if (Date.now() - verification.timestamp > 5 * 60 * 1000) {
+        verificationCodes.delete(phoneNumber);
+        return res.status(400).json({
+            success: false,
+            message: 'Le code a expiré'
+        });
+    }
+
+    // Vérifier le code
+    if (verification.code.toString() === code.toString()) {
+        verificationCodes.delete(phoneNumber);
+        res.json({
+            success: true,
+            message: 'Code vérifié avec succès'
+        });
+    } else {
+        verification.attempts += 1;
+        
+        if (verification.attempts >= 3) {
+            verificationCodes.delete(phoneNumber);
+            res.status(400).json({
+                success: false,
+                message: 'Trop de tentatives. Veuillez demander un nouveau code'
+            });
+        } else {
+            res.status(400).json({
+                success: false,
+                message: 'Code incorrect'
+            });
+        }
+    }
 });
+
+// Démarrage du serveur
+app.listen(config.PORT, () => {
+    console.log(`Serveur démarré sur le port ${config.PORT}`);
+});