ce2c399055
All checks were successful
Build and Push to Registry / build-and-push (push) Successful in 33s
978 lines
27 KiB
JavaScript
978 lines
27 KiB
JavaScript
const express = require('express');
|
|
const cors = require('cors');
|
|
const fetch = require('node-fetch');
|
|
const { v4: uuidv4 } = require('uuid');
|
|
const ovh = require('ovh');
|
|
const mailchimp = require('@mailchimp/mailchimp_transactional');
|
|
const Stripe = require('stripe');
|
|
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', 'https://lecoffreio.4nkweb.com'],
|
|
methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
|
|
allowedHeaders: ['Content-Type', 'Authorization']
|
|
};
|
|
|
|
app.use(cors(corsOptions));
|
|
app.use(express.json());
|
|
|
|
const authTokens = [];
|
|
|
|
const ECivility = {
|
|
MALE: 'MALE',
|
|
FEMALE: 'FEMALE',
|
|
OTHERS: 'OTHERS'
|
|
};
|
|
|
|
const EOfficeStatus = {
|
|
ACTIVATED: 'ACTIVATED',
|
|
DESACTIVATED: 'DESACTIVATED'
|
|
};
|
|
|
|
const EIdnotRole = {
|
|
DIRECTEUR: "Directeur général du CSN",
|
|
NOTAIRE_TITULAIRE: "Notaire titulaire",
|
|
NOTAIRE_ASSOCIE: "Notaire associé",
|
|
NOTAIRE_SALARIE: "Notaire salarié",
|
|
COLLABORATEUR: "Collaborateur",
|
|
SECRETAIRE_GENERAL: "Secrétaire général",
|
|
SUPPLEANT: "Suppléant",
|
|
ADMINISTRATEUR: "Administrateur",
|
|
RESPONSABLE: "Responsable",
|
|
CURATEUR: "Curateur",
|
|
}
|
|
|
|
function getOfficeStatus(statusName) {
|
|
switch (statusName) {
|
|
case "Pourvu":
|
|
return EOfficeStatus.ACTIVATED;
|
|
case "Pourvu mais décédé":
|
|
return EOfficeStatus.ACTIVATED;
|
|
case "Sans titulaire":
|
|
return EOfficeStatus.ACTIVATED;
|
|
case "Vacance":
|
|
return EOfficeStatus.ACTIVATED;
|
|
case "En activité":
|
|
return EOfficeStatus.ACTIVATED;
|
|
default:
|
|
return EOfficeStatus.DESACTIVATED;
|
|
}
|
|
}
|
|
|
|
function getOfficeRole(roleName) {
|
|
switch (roleName) {
|
|
case EIdnotRole.NOTAIRE_TITULAIRE:
|
|
return { name: 'Notaire' };
|
|
case EIdnotRole.NOTAIRE_ASSOCIE:
|
|
return { name: 'Notaire' };
|
|
case EIdnotRole.NOTAIRE_SALARIE:
|
|
return { name: 'Notaire' };
|
|
case EIdnotRole.COLLABORATEUR:
|
|
return { name: 'Collaborateur' };
|
|
case EIdnotRole.SUPPLEANT:
|
|
return { name: 'Collaborateur' };
|
|
case EIdnotRole.ADMINISTRATEUR:
|
|
return { name: 'Collaborateur' };
|
|
case EIdnotRole.CURATEUR:
|
|
return { name: 'Collaborateur' };
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function getRole(roleName) {
|
|
switch (roleName) {
|
|
case EIdnotRole.NOTAIRE_TITULAIRE:
|
|
return { name: 'admin' };
|
|
case EIdnotRole.NOTAIRE_ASSOCIE:
|
|
return { name: 'admin' };
|
|
case EIdnotRole.NOTAIRE_SALARIE:
|
|
return { name: 'notary' };
|
|
case EIdnotRole.COLLABORATEUR:
|
|
return { name: 'notary' };
|
|
case EIdnotRole.SUPPLEANT:
|
|
return { name: 'notary' };
|
|
case EIdnotRole.ADMINISTRATEUR:
|
|
return { name: 'admin' };
|
|
case EIdnotRole.CURATEUR:
|
|
return { name: 'notary' };
|
|
default:
|
|
return { name: 'default' };
|
|
}
|
|
}
|
|
|
|
function getCivility(civility) {
|
|
switch (civility) {
|
|
case 'Monsieur':
|
|
return ECivility.MALE;
|
|
case 'Madame':
|
|
return ECivility.FEMALE;
|
|
default:
|
|
return ECivility.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({
|
|
key: 'ba557f84-0bf6-4dbf-844f-df2767555e3e'
|
|
});
|
|
|
|
let userData;
|
|
try {
|
|
userData = await (
|
|
await fetch(`https://qual-api.notaires.fr/annuaire/api/pp/v2/rattachements/${payload.profile_idn}?` + searchParams, {
|
|
method: 'GET'
|
|
})
|
|
).json();
|
|
} catch (error) {
|
|
console.error('Error fetching ' + `https://qual-api.notaires.fr/annuaire/api/pp/v2/rattachements/${payload.profile_idn}`, error);
|
|
return null;
|
|
}
|
|
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)
|
|
},
|
|
office_role: getOfficeRole(userData.typeLien.name)
|
|
};
|
|
|
|
if (!idNotUser.contact.email) {
|
|
console.error('User pro email empty');
|
|
return null;
|
|
}
|
|
|
|
const authToken = uuidv4();
|
|
authTokens.push({ idNot: idNotUser.idNot, authToken });
|
|
|
|
res.json({ idNotUser, authToken });
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
error: 'Internal Server Error',
|
|
message: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
//------------------------------------ SMS Section -----------------------------------------
|
|
|
|
const configSms = {
|
|
// OVH config
|
|
OVH_APP_KEY: process.env.OVH_APP_KEY,
|
|
OVH_APP_SECRET: process.env.OVH_APP_SECRET,
|
|
OVH_CONSUMER_KEY: process.env.OVH_CONSUMER_KEY,
|
|
OVH_SMS_SERVICE_NAME: process.env.OVH_SMS_SERVICE_NAME,
|
|
|
|
// SMS Factor config
|
|
SMS_FACTOR_TOKEN: process.env.SMS_FACTOR_TOKEN,
|
|
|
|
PORT: process.env.PORT || 8080
|
|
};
|
|
|
|
// Codes storage
|
|
const verificationCodes = new Map();
|
|
|
|
// Service SMS
|
|
class SmsService {
|
|
static generateCode() {
|
|
return Math.floor(100000 + Math.random() * 900000);
|
|
}
|
|
|
|
// OVH Service
|
|
static sendSmsWithOvh(phoneNumber, message) {
|
|
return new Promise((resolve, reject) => {
|
|
const ovhClient = ovh({
|
|
appKey: configSms.OVH_APP_KEY,
|
|
appSecret: configSms.OVH_APP_SECRET,
|
|
consumerKey: configSms.OVH_CONSUMER_KEY
|
|
});
|
|
|
|
ovhClient.request('POST', `/sms/${configSms.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 });
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
// SMS Factor Service
|
|
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', configSms.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' };
|
|
}
|
|
}
|
|
|
|
// Main method
|
|
static async sendSms(phoneNumber, message) {
|
|
// Try first with OVH
|
|
const ovhResult = await this.sendSmsWithOvh(phoneNumber, message);
|
|
|
|
if (ovhResult.success) {
|
|
return ovhResult;
|
|
}
|
|
|
|
// If OVH fails, try with SMS Factor
|
|
console.log('OVH SMS failed, trying SMS Factor...');
|
|
return await this.sendSmsWithSmsFactor(phoneNumber, message);
|
|
}
|
|
}
|
|
|
|
// Phone number validation middleware
|
|
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-code', validatePhoneNumber, async (req, res) => {
|
|
const { phoneNumber } = req.body;
|
|
|
|
try {
|
|
// Check if a code already exists and is not expired
|
|
const existingVerification = verificationCodes.get(phoneNumber);
|
|
if (existingVerification) {
|
|
const timeSinceLastSend = Date.now() - existingVerification.timestamp;
|
|
if (timeSinceLastSend < 30000) { // 30 secondes
|
|
return res.status(429).json({
|
|
success: false,
|
|
message: 'Veuillez attendre 30 secondes avant de demander un nouveau code'
|
|
});
|
|
}
|
|
}
|
|
|
|
// Generate a new code
|
|
const code = SmsService.generateCode();
|
|
|
|
// Store the code
|
|
verificationCodes.set(phoneNumber, {
|
|
code,
|
|
timestamp: Date.now(),
|
|
attempts: 0
|
|
});
|
|
|
|
// Send the 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('Erreur:', error);
|
|
res.status(500).json({
|
|
success: false,
|
|
message: 'Erreur serveur lors de l\'envoi du code'
|
|
});
|
|
}
|
|
});
|
|
|
|
app.post('/api/verify-code', validatePhoneNumber, (req, res) => {
|
|
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'
|
|
});
|
|
}
|
|
|
|
// Check if the code has not expired (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é'
|
|
});
|
|
}
|
|
|
|
// Check if the code is correct
|
|
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'
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
//------------------------------------ End of SMS Section ------------------------------------
|
|
|
|
//------------------------------------ Email Section -----------------------------------------
|
|
|
|
|
|
const configEmail = {
|
|
MAILCHIMP_API_KEY: process.env.MAILCHIMP_API_KEY,
|
|
MAILCHIMP_KEY: process.env.MAILCHIMP_KEY,
|
|
MAILCHIMP_LIST_ID: process.env.MAILCHIMP_LIST_ID,
|
|
PORT: process.env.PORT || 8080,
|
|
FROM_EMAIL: 'no-reply@lecoffre.io',
|
|
FROM_NAME: 'LeCoffre.io'
|
|
};
|
|
|
|
// Email storage
|
|
const pendingEmails = new Map();
|
|
|
|
// Email service
|
|
class EmailService {
|
|
static async sendTransactionalEmail(to, templateName, subject, templateVariables) {
|
|
try {
|
|
const mailchimpClient = mailchimp(configEmail.MAILCHIMP_API_KEY);
|
|
|
|
const message = {
|
|
template_name: templateName,
|
|
template_content: [],
|
|
message: {
|
|
global_merge_vars: this.buildVariables(templateVariables),
|
|
from_email: configEmail.FROM_EMAIL,
|
|
from_name: configEmail.FROM_NAME,
|
|
subject: subject,
|
|
to: [
|
|
{
|
|
email: to,
|
|
type: 'to'
|
|
}
|
|
]
|
|
}
|
|
};
|
|
|
|
const result = await mailchimpClient.messages.sendTemplate(message);
|
|
return { success: true, result };
|
|
} catch (error) {
|
|
console.error('Erreur envoi email:', error);
|
|
return { success: false, error: 'Échec de l\'envoi de l\'email' };
|
|
}
|
|
}
|
|
|
|
static buildVariables(templateVariables) {
|
|
return Object.keys(templateVariables).map(key => ({
|
|
name: key,
|
|
content: templateVariables[key]
|
|
}));
|
|
}
|
|
|
|
// Add to Mailchimp diffusion list
|
|
static async addToMailchimpList(email) {
|
|
try {
|
|
const url = `https://us17.api.mailchimp.com/3.0/lists/${configEmail.MAILCHIMP_LIST_ID}/members`;
|
|
|
|
const response = await fetch(url, {
|
|
method: 'POST',
|
|
headers: {
|
|
'Authorization': `apikey ${configEmail.MAILCHIMP_KEY}`,
|
|
'Content-Type': 'application/json'
|
|
},
|
|
body: JSON.stringify({
|
|
email_address: email,
|
|
status: 'subscribed'
|
|
})
|
|
});
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`HTTP error! status: ${response.status}`);
|
|
}
|
|
|
|
const data = await response.json();
|
|
return { success: true, data };
|
|
} catch (error) {
|
|
console.error('Erreur ajout à la liste:', error);
|
|
return { success: false, error: 'Échec de l\'ajout à la liste Mailchimp' };
|
|
}
|
|
}
|
|
|
|
static async retryFailedEmails() {
|
|
for (const [emailId, emailData] of pendingEmails) {
|
|
if (emailData.attempts >= 10) {
|
|
pendingEmails.delete(emailId);
|
|
continue;
|
|
}
|
|
|
|
const nextRetryDate = new Date(emailData.lastAttempt);
|
|
nextRetryDate.setMinutes(nextRetryDate.getMinutes() + Math.pow(emailData.attempts, 2));
|
|
|
|
if (Date.now() >= nextRetryDate) {
|
|
try {
|
|
const result = await this.sendTransactionalEmail(
|
|
emailData.to,
|
|
emailData.templateName,
|
|
emailData.subject,
|
|
emailData.templateVariables
|
|
);
|
|
|
|
if (result.success) {
|
|
pendingEmails.delete(emailId);
|
|
} else {
|
|
emailData.attempts += 1;
|
|
emailData.lastAttempt = Date.now();
|
|
}
|
|
} catch (error) {
|
|
emailData.attempts += 1;
|
|
emailData.lastAttempt = Date.now();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Email validation middleware
|
|
const validateEmail = (req, res, next) => {
|
|
const { email } = req.body;
|
|
|
|
if (!email) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: 'L\'adresse email est requise'
|
|
});
|
|
}
|
|
|
|
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
|
|
if (!emailRegex.test(email)) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: 'Format d\'email invalide'
|
|
});
|
|
}
|
|
|
|
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",
|
|
};
|
|
|
|
// Routes
|
|
app.post('/api/send-email', validateEmail, async (req, res) => {
|
|
const { email, firstName, lastName, officeName, template } = req.body;
|
|
|
|
try {
|
|
const templateVariables = {
|
|
first_name: firstName || '',
|
|
last_name: lastName || '',
|
|
office_name: officeName || '',
|
|
link: `${process.env.APP_HOST}`
|
|
};
|
|
|
|
const result = await EmailService.sendTransactionalEmail(
|
|
email,
|
|
ETemplates[template],
|
|
'Votre notaire vous envoie un message',
|
|
templateVariables
|
|
);
|
|
|
|
if (!result.success) {
|
|
// Add to pending emails to retry later
|
|
const emailId = `${email}-${Date.now()}`;
|
|
pendingEmails.set(emailId, {
|
|
to: email,
|
|
templateName: ETemplates[template],
|
|
subject: 'Votre notaire vous envoie un message',
|
|
templateVariables,
|
|
attempts: 1,
|
|
lastAttempt: Date.now()
|
|
});
|
|
}
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Email envoyé avec succès'
|
|
});
|
|
} catch (error) {
|
|
console.error('Erreur:', error);
|
|
res.status(500).json({
|
|
success: false,
|
|
message: 'Erreur serveur lors de l\'envoi de l\'email'
|
|
});
|
|
}
|
|
});
|
|
|
|
app.post('/api/subscribe-to-list', validateEmail, async (req, res) => {
|
|
const { email } = req.body;
|
|
|
|
try {
|
|
const result = await EmailService.addToMailchimpList(email);
|
|
|
|
if (result.success) {
|
|
res.json({
|
|
success: true,
|
|
message: 'Inscription à la liste réussie'
|
|
});
|
|
} else {
|
|
res.status(500).json({
|
|
success: false,
|
|
message: 'Échec de l\'inscription à la liste'
|
|
});
|
|
}
|
|
} catch (error) {
|
|
console.error('Erreur:', error);
|
|
res.status(500).json({
|
|
success: false,
|
|
message: 'Erreur serveur lors de l\'inscription'
|
|
});
|
|
}
|
|
});
|
|
|
|
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();
|
|
}, 60000); // Check every minute
|
|
|
|
//------------------------------------ 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}`);
|
|
});
|