Merge branch 'main' of https://git.4nkweb.com/4nk/lecoffre-back-mini

.env.exemple

@@ -11,7 +11,20 @@ SMS_FACTOR_TOKEN=
 MAILCHIMP_API_KEY=
 MAILCHIMP_KEY=
 MAILCHIMP_LIST_ID=
-APP_HOST=
+
+
+#Configuration Stripe
+STRIPE_SECRET_KEY=
+STRIPE_WEBHOOK_SECRET=
+STRIPE_STANDARD_SUBSCRIPTION_PRICE_ID=
+STRIPE_STANDARD_ANNUAL_SUBSCRIPTION_PRICE_ID=
+STRIPE_UNLIMITED_SUBSCRIPTION_PRICE_ID=
+STRIPE_UNLIMITED_ANNUAL_SUBSCRIPTION_PRICE_ID=
+
+#Cartes de test Stripe
+SUCCES= 4242 4242 4242 4242   #Paiement réussi
+DECLINED= 4000 0025 0000 3155   #Paiement refusé
 
 # Configuration serveur
+APP_HOST=
 PORT=

package.json

@@ -13,7 +13,9 @@
     "dotenv": "^17.2.0",
     "express": "^4.18.2",
     "node-fetch": "^2.6.7",
-    "ovh": "^2.0.3"
+    "ovh": "^2.0.3",
+    "stripe": "^18.3.0",
+    "uuid": "^11.1.0"
   },
   "devDependencies": {
     "nodemon": "^3.0.1"

src/server.js

@@ -3,6 +3,7 @@ const cors = require('cors');
 const fetch = require('node-fetch');
 const ovh = require('ovh');
 const mailchimp = require('@mailchimp/mailchimp_transactional');
+const Stripe = require('stripe');
 require('dotenv').config();
 
 // Initialisation de l'application Express
@@ -533,12 +534,12 @@ const validateEmail = (req, res, next) => {
 
 // Email templates
 const ETemplates = {
-DOCUMENT_ASKED: "DOCUMENT_ASKED",
-DOCUMENT_REFUSED: "DOCUMENT_REFUSED",
-DOCUMENT_RECAP: "DOCUMENT_RECAP",
-SUBSCRIPTION_INVITATION: "SUBSCRIPTION_INVITATION",
-DOCUMENT_REMINDER: "DOCUMENT_REMINDER",
-DOCUMENT_SEND: "DOCUMENT_SEND",
+  DOCUMENT_ASKED: "DOCUMENT_ASKED",
+  DOCUMENT_REFUSED: "DOCUMENT_REFUSED",
+  DOCUMENT_RECAP: "DOCUMENT_RECAP",
+  SUBSCRIPTION_INVITATION: "SUBSCRIPTION_INVITATION",
+  DOCUMENT_REMINDER: "DOCUMENT_REMINDER",
+  DOCUMENT_SEND: "DOCUMENT_SEND",
 };
 
 // Routes
@@ -612,6 +613,73 @@ app.post('/api/subscribe-to-list', validateEmail, async (req, res) => {
   }
 });
 
+app.post('/api/:uid/send_reminder', validateEmail, async (req, res) => {
+  const { email, documentsUid } = req.body;
+
+  try {
+    const uid = req.params["uid"];
+    if (!uid) {
+      //this.httpBadRequest(response, "No uid provided");
+      return;
+    }
+
+    if (!documentsUid || !Array.isArray(documentsUid)) {
+      //this.httpBadRequest(response, "Invalid or missing documents");
+      return;
+    }
+
+    /*
+    const documentEntities: Documents[] = [];
+    //For each document uid, use DocumentsService.getByUid to get the document entity and add it to the documents array
+    for (const documentUid of documentsUid) {
+      const documentEntity = await this.documentsService.getByUid(documentUid, { document_type: true, folder: true });
+
+      if (!documentEntity) {
+        this.httpBadRequest(response, "Document not found");
+        return;
+      }
+      documentEntities.push(documentEntity);
+    }
+
+    const customerEntity = await this.customersService.getByUid(uid, { contact: true, office: true });
+
+    if (!customerEntity) {
+      this.httpNotFoundRequest(response, "customer not found");
+      return;
+    }
+
+    //Hydrate ressource with prisma entity
+    const customer = Customer.hydrate < Customer > (customerEntity, { strategy: "excludeAll" });
+
+    // Call service to send reminder with documents
+    await this.customersService.sendDocumentsReminder(customer, documentEntities);
+    */
+
+    const templateVariables = {
+      first_name: 'firstName' || '',
+      last_name: 'lastName' || '',
+      office_name: 'officeName' || '',
+      link: `${process.env.APP_HOST}`
+    };
+
+    const result = await EmailService.sendTransactionalEmail(
+      email,
+      ETemplates.DOCUMENT_REMINDER,
+      'Votre notaire vous envoie un message',
+      templateVariables
+    );
+    console.log(result);
+
+    res.json({
+      success: true,
+      message: 'Email envoyé avec succès'
+    });
+  } catch (error) {
+    console.log(error);
+    return;
+  }
+});
+
 // Automatic retry system
 setInterval(() => {
   EmailService.retryFailedEmails();
@@ -619,6 +687,239 @@ setInterval(() => {
 
 //------------------------------------ End of Email Section ------------------------------------
 
+//------------------------------------ Stripe Section ------------------------------------------
+
+const configStripe = {
+  STRIPE_SECRET_KEY: process.env.STRIPE_SECRET_KEY,
+  STRIPE_WEBHOOK_SECRET: process.env.STRIPE_WEBHOOK_SECRET,
+  APP_HOST: process.env.APP_HOST || 'http://localhost:3000',
+};
+
+// Stripe service
+class StripeService {
+  constructor() {
+    this.client = new Stripe(configStripe.STRIPE_SECRET_KEY);
+    this.prices = {
+      STANDARD: {
+        monthly: process.env.STRIPE_STANDARD_SUBSCRIPTION_PRICE_ID,
+        yearly: process.env.STRIPE_STANDARD_ANNUAL_SUBSCRIPTION_PRICE_ID
+      },
+      UNLIMITED: {
+        monthly: process.env.STRIPE_UNLIMITED_SUBSCRIPTION_PRICE_ID,
+        yearly: process.env.STRIPE_UNLIMITED_ANNUAL_SUBSCRIPTION_PRICE_ID
+      }
+    };
+  }
+
+  // Only for test
+  async createTestSubscription() {
+    try {
+      const customer = await this.client.customers.create({
+        email: 'test@example.com',
+        description: 'Client test',
+        source: 'tok_visa'
+      });
+
+      const priceId = this.prices.STANDARD.monthly;
+      const price = await this.client.prices.retrieve(priceId);
+
+      const subscription = await this.client.subscriptions.create({
+        customer: customer.id,
+        items: [{ price: price.id }],
+        payment_behavior: 'default_incomplete',
+        expand: ['latest_invoice.payment_intent']
+      });
+
+      return {
+        subscriptionId: subscription.id,
+        customerId: customer.id,
+        status: subscription.status,
+        priceId: price.id
+      };
+
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async createCheckoutSession(subscription, frequency) {
+    const priceId = this.getPriceId(subscription.type, frequency);
+
+    return await this.client.checkout.sessions.create({
+      mode: 'subscription',
+      payment_method_types: ['card', 'sepa_debit'],
+      billing_address_collection: 'auto',
+      line_items: [{
+        price: priceId,
+        quantity: subscription.type === 'STANDARD' ? subscription.seats : 1,
+      }],
+      success_url: `${configStripe.APP_HOST}/subscription/success`, // Success page (frontend)
+      cancel_url: `${configStripe.APP_HOST}/subscription/error`, // Error page (frontend)
+      metadata: {
+        subscription: JSON.stringify(subscription),
+      },
+      allow_promotion_codes: true,
+      automatic_tax: { enabled: true }
+    });
+  }
+
+  getPriceId(type, frequency) {
+    return this.prices[type][frequency];
+  }
+
+  async getSubscription(subscriptionId) {
+    return await this.client.subscriptions.retrieve(subscriptionId);
+  }
+
+  async createPortalSession(subscriptionId) {
+    const subscription = await this.getSubscription(subscriptionId);
+    return await this.client.billingPortal.sessions.create({
+      customer: subscription.customer,
+      return_url: `${configStripe.APP_HOST}/subscription/manage`
+    });
+  }
+}
+
+const stripeService = new StripeService();
+
+// Validation middleware
+const validateSubscription = (req, res, next) => {
+  const { type, seats, frequency } = req.body;
+
+  if (!type || !['STANDARD', 'UNLIMITED'].includes(type)) {
+    return res.status(400).json({
+      success: false,
+      message: 'Type d\'abonnement invalide'
+    });
+  }
+
+  if (type === 'STANDARD' && (!seats || seats < 1)) {
+    return res.status(400).json({
+      success: false,
+      message: 'Nombre de sièges invalide'
+    });
+  }
+
+  if (!frequency || !['monthly', 'yearly'].includes(frequency)) {
+    return res.status(400).json({
+      success: false,
+      message: 'Fréquence invalide'
+    });
+  }
+
+  next();
+};
+
+// Routes
+
+// Only for test
+app.post('/api/test/create-subscription', async (req, res) => {
+  try {
+    const result = await stripeService.createTestSubscription();
+    res.json({
+      success: true,
+      data: result
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Erreur lors de la création de l\'abonnement de test',
+      error: {
+        message: error.message,
+        type: error.type,
+        code: error.code
+      }
+    });
+  }
+});
+
+app.post('/api/subscriptions/checkout', validateSubscription, async (req, res) => {
+  try {
+    const session = await stripeService.createCheckoutSession(req.body, req.body.frequency);
+    res.json({ success: true, sessionId: session.id });
+  } catch (error) {
+    console.error('Erreur création checkout:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Erreur lors de la création de la session de paiement'
+    });
+  }
+});
+
+app.get('/api/subscriptions/:id', async (req, res) => {
+  try {
+    const subscription = await stripeService.getSubscription(req.params.id);
+    res.json({ success: true, subscription });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Erreur lors de la récupération de l\'abonnement'
+    });
+  }
+});
+
+app.post('/api/subscriptions/:id/portal', async (req, res) => {
+  try {
+    const session = await stripeService.createPortalSession(req.params.id);
+    res.json({ success: true, url: session.url });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Erreur lors de la création de la session du portail'
+    });
+  }
+});
+
+// Webhook Stripe
+app.post('/api/webhooks/stripe', express.raw({ type: 'application/json' }), async (req, res) => {
+  const sig = req.headers['stripe-signature'];
+  let event;
+
+  try {
+    event = Stripe.webhooks.constructEvent(req.body, sig, configStripe.STRIPE_WEBHOOK_SECRET);
+  } catch (err) {
+    return res.status(400).send(`Webhook Error: ${err.message}`);
+  }
+
+  try {
+    switch (event.type) {
+      case 'checkout.session.completed':
+        const session = event.data.object;
+        if (session.status === 'complete') {
+          const subscription = JSON.parse(session.metadata.subscription);
+          // Stock subscription (create process)
+          console.log('Nouvel abonnement:', subscription);
+        }
+        break;
+
+      case 'invoice.payment_succeeded':
+        const invoice = event.data.object;
+        if (['subscription_update', 'subscription_cycle'].includes(invoice.billing_reason)) {
+          const subscription = await stripeService.getSubscription(invoice.subscription);
+          // Update subscription (update process)
+          console.log('Mise à jour abonnement:', subscription);
+        }
+        break;
+
+      case 'customer.subscription.deleted':
+        const deletedSubscription = event.data.object;
+        // Delete subscription (update process to delete)
+        console.log('Suppression abonnement:', deletedSubscription.id);
+        break;
+    }
+
+    res.json({ received: true });
+  } catch (error) {
+    console.error('Erreur webhook:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Erreur lors du traitement du webhook'
+    });
+  }
+});
+
+//------------------------------------ End of Stripe Section -----------------------------------
+
 app.listen(PORT, () => {
   console.log(`Server is running on port ${PORT}`);
 });