const bcrypt = require("bcrypt"); const jwt = require("jsonwebtoken"); const slugify = require('slugify'); const { Op, QueryTypes } = require("sequelize");// pour certaines requêtes sql const config = require("../config/main.js"); const configUsers = require("../config/users.js"); const configTpl = require("../views/"+config.theme+"/config/"+config.availableLangs[0]+".js"); const tool = require("../tools/main"); const toolError = require("../tools/error"); const toolFile = require("../tools/file"); const toolMail = require("../tools/mail"); const txt = require("../lang/"+config.adminLang+"/user"); const txtGeneral = require("../lang/"+config.adminLang+"/general"); const answerCtrl = require("./answer"); const subscriptionCtrl = require("./subscription"); // Retourne certaines configurations utiles aux formulaires où vues exports.checkEmailIsFree = async (req, res, next) => { try { const user=await searchUserByEmail(req.body.emailTest); const response={ }; if(user) { response.free=false; if(user.Subscription) response.validated=true; else response.validated=false; } else response.free=true; res.status(200).json(response); next(); } catch(e) { next(e); } } exports.getGodfatherId = async (req, res, next) => { try { const godfather=await searchIdGodfather(req.body.codeTest); if(godfather) res.status(200).json(godfather.id); else res.status(204).json({ errors: txt.godfatherNotFound }); next(); } catch(e) { next(e); } } // Contrôleur traitant les données envoyées pour une inscription // Les CGU doivent être acceptées et une adresse e-mail envoyée. // Un champ email2 invisible ne devrait être envoyé que par des bots // Le reste peut être adapté sur la page de validation de l'inscription. exports.signup = async (req, res, next) => { try { const db = require("../models/index"); if(req.body.cguOk !== "true") res.status(400).json({ errors: [txt.needUGCOk] }); else if(tool.isEmpty(req.body.email)) res.status(400).json({ errors: [txt.needEmail] }); else if(!tool.isEmpty(req.body.email2)) { res.status(400).json({ errors: [txt.failBotTest] }); console.log(txt.failBotTestLog+req.body.email2); } else { // Un mot de passe temporaire et non communiqué est généré : req.body.passwordTemp=tool.getPassword(8, 12); req.body.password=await bcrypt.hash(req.body.passwordTemp, config.bcryptSaltRounds); // Un pseudo temporaire est créé en utilisant la partie de l'e-mail précédant le "@" : const lastIndex=req.body.email.indexOf("@"); if(lastIndex === -1)// possible car validité de l'e-mail testé par le modèle lors de l'enregistrement lastIndex=1; req.body.name=req.body.email.substring(0, lastIndex); const user=await db["User"].create({ ...req.body }, { fields: ["name", "email", "password", "timeDifference"] }); req.body.UserId=user.id; // Si l'utilisateur a répondu à un quiz (ou groupe de quizs) avant de créer son compte, on enregistre son résultat : if(req.body.QuestionnaireId) await answerCtrl.saveAnswerToQuestionnaire(req.body); else if(req.body.GroupId) await answerCtrl.saveAnswerToGroup(req.body); await sendValidationLink(user); res.status(201).json({ message: txt.mailValidationMessage.replace("#EMAIL", req.body.email) }); next(); } } catch(e) { const returnAPI=toolError.returnSequelize(e); if(returnAPI.messages) { res.status(returnAPI.status).json({ errors : returnAPI.messages }); next(); } else next(e); } } // Contrôleur testant le lien de validation du compte et envoyant un message de bienvenue si tout est ok exports.signupValidation = async (req, res, next) => { try { const db = require("../models/index"); const datas=await checkTokenUser(req.params.token); if(datas) { if(datas.Subscription) res.status(200).json({ errors: [txt.validationAlreadyMessage.replace("#URL", configTpl.connectionPage)] }); else { const now=new Date(); await Promise.all([ db["Subscription"].create({ numberOfDays: config.freeAccountTimingInDays, receiptDays: config.defaultReceiptDays, UserId: datas.User.id }), db["User"].update({ connectedAt: now }, { where: { id : datas.User.id }, limit:1 }) ]); const newUser=await creaUserJson(datas.User.id); const mapMail = { USER_NAME: datas.User.name, NOM_SITE : config.siteName, EMAIL: config.senderEmail, LINK_URL: config.siteUrl+"/"+configTpl.connectionPage }; const mailDatas = { mailSubject: txt.mailWelcomeSubject, mailPreheader: txt.mailWelcomeSubject, mailTitle: txt.mailWelcomeSubject, mailHeaderLinkUrl: config.siteUrl+"/"+configTpl.connectionPage, mailHeaderLinkTxt: txt.mailWelcomeLinkTxt, mailMainContent: tool.replaceAll(txt.mailWelcomeBodyHTML, mapMail), linksCTA: [{ url:config.siteUrl+"/"+configTpl.connectionPage, txt:txt.mailWelcomeLinkTxt }], mailRecipientAddress: datas.User.email } toolMail.sendMail(0, datas.User.email, txt.mailWelcomeSubject, tool.replaceAll(txt.mailWelcomeBodyTxt, mapMail), "", mailDatas); res.status(200).json( { newUser: newUser, token: jwt.sign({ userId: datas.User.id }, config.tokenPrivateKey, { expiresIn: config.tokenConnexionMinTimeInHours }) }); } } else res.status(401).json({ errors: txt.badLinkValidationMessage }); next(); } catch(e) { next(e); } } // Contrôleur recevant les données envoyées par l'utilisateur lorsqu'il lui est demandé de complèter ses informations, juste après avoir validé son abonnement // Il peut fournir ici un pseudo et un mot de passe de son choix ou encore un code parrain // Il peut asussi choisir les jours de réception de son abonnement au site exports.signUpCompletion = async (req, res, next) => { try { const db = require("../models/index"); if(!tool.isEmpty(req.body.newPassword) && req.body.newPassword.length < config.passwordMinLength) res.status(400).json({ errors: txt.needLongPassWord.replace("MIN_LENGTH", config.passwordMinLength) }); else { if(!tool.isEmpty(req.body.newPassword))// dans ce cas, l'utilisateur n'a pas choisi de mot de passe, mais pourra se connecter via les tokens de connexion req.body.password=await bcrypt.hash(req.body.newPassword, config.bcryptSaltRounds); req.body.GodfatherId=null; if(req.body.codeGodfather !== "") { const godfather=await searchIdGodfather(req.body.codeGodfather); if(godfather && godfather.id !== req.connectedUser.User.id) // des fois qu'il se serait désigné lui-même comme "parrain" :) req.body.GodfatherId=godfather.id; } await Promise.all([ db["User"].update({ ...req.body }, { where: { id : req.connectedUser.User.id } , fields: ["name", "password", "GodfatherId"], limit:1 }), db["Subscription"].update({ ...req.body }, { where: { UserId : req.connectedUser.User.id }, fields: ["receiptDays"], limit:1 }) ]); const user=await creaUserJson(req.connectedUser.User.id); // Si un parrain a été désigné, on prévient l'heureux élu :) : if(user!==false && req.body.GodfatherId !== null) { const godfather=await searchUserById(req.body.GodfatherId); if(godfather) { const mapMail = { USER_NAME: godfather.User.name, NOM_SITE : config.siteName, EMAIL : user.User.email, LINK_URL : config.siteUrl+"/"+configTpl.connectionPage }; const mailDatas= { mailSubject: txt.mailThankGodfatherSubject, mailPreheader: txt.mailThankGodfatherSubject, mailTitle: txt.mailThankGodfatherSubject, mailHeaderLinkUrl: config.siteUrl+"/"+configTpl.connectionPage, mailHeaderLinkTxt: txt.mailThankGodfatherLinkTxt, mailMainContent: tool.replaceAll(txt.mailThankGodfatherBodyHTML, mapMail), mailRecipientAddress: godfather.User.email } toolMail.sendMail(godfather.User.smtp, godfather.User.email, txt.mailThankGodfatherSubject, tool.replaceAll(txt.mailThankGodfatherBodyTxt, mapMail), "", mailDatas); } } const messageRetour=[txt.updatedOkMessage]; res.status(200).json({ message: messageRetour }); } next(); } catch(e) { const returnAPI=toolError.returnSequelize(e); if(returnAPI.messages) { res.status(returnAPI.status).json({ errors : returnAPI.messages }); next(); } else next(e); } } exports.checkToken = async (req, res, next) => { try { const datas=await checkTokenUser(req.params.token); if(datas && datas.Subscription) { const beginSubTS=new Date(datas.Subscription.createdAt).getTime(); // Si abonnement illimité, pas besoin de calculer le nbre de jours restants const nbDaysOk=(datas.Subscription.numberOfDays===0) ? 1 : datas.Subscription.numberOfDays-Math.round((Date.now()-beginSubTS)/1000/3600/24); res.status(200).json( { isValid: true, id: datas.User.id, name: datas.User.name, language: datas.User.language, timeDifference : datas.User.timeDifference, status: datas.User.status, nbDaysOk : nbDaysOk }); } else res.status(200).json({ isValid: false }); next(); } catch(e) { next(e); } } // Reçoit les données du formulaire de connexion avec mot de passe. exports.login = async (req, res, next) => { try { const db = require("../models/index"); // Est-ce qu'un compte existe pour l'adresse e-mail envoyée ? const emailSend=tool.trimIfNotNull(req.body.email); const user=await db["User"].findOne({ attributes: ["id", "password", "email", "name", "status"], where: { email: emailSend } }); if(!user) res.status(404).json({ errors: [txt.emailNotFound] }); else { // Est-ce ce compte a déjà été validé par l'utilisateur ? Si non, on lui envoie un nouveau lien de validation. const subscription=await db["Subscription"].findOne({ attributes: ["id"], where: { UserId: user.id } }); if(!subscription) { await sendValidationLink(user); res.status(400).json({ errors: [txt.needValidationToLogin] }); } else { const nowTS=new Date().getTime(); // L'utilisateur n'a-t-il pas testé de se connecter de trop nombreuses fois sans succès ? const countLogin=await toolFile.readJSON(config.dirTmpLogin, slugify(emailSend)); if(countLogin && countLogin.nb >= config.maxLoginFail && countLogin.lastTime > (nowTS-config.loginFailTimeInMinutes*60*1000)) res.status(401).json({ errors: [txt.tooManyLoginFails.replace("MINUTES", config.loginFailTimeInMinutes)] }); else { // Le mot du passe envoyé est-il cohérent avec celui de la base de données après chiffrement ? const valid = await bcrypt.compare(req.body.password, user.password); if (!valid) { res.status(401).json({ errors: [txt.badPassword] }); // On comptabilise l'erreur : let newCountLogin={ nb:1, lastTime:nowTS }; if(countLogin.nb && countLogin.lastTime > (nowTS-config.loginFailTimeInMinutes*60*1000)) newCountLogin.nb=countLogin.nb+1; await toolFile.createJSON(config.dirTmpLogin, slugify(emailSend), newCountLogin); } else { // Si tout est ok, on enregistre la date de connexion + retourne un token de connexion. const now=new Date(); const timeDifference=req.body.timeDifference; db["User"].update({ connectedAt: now, timeDifference: timeDifference }, { where: { id : user.id }, limit:1 }); await creaUserJson(user.id); // Connexion à rallonge uniquement possible pour utilisateur de base : let loginTime=config.tokenConnexionMinTimeInHours; if((req.body.keepConnected === "true") && (user.status === "user")) loginTime=config.tokenConnexionMaxTimeInDays; // Si l'utilisateur a répondu à un quiz (ou groupe de quizs) avant de se connecter, on enregistre son résultat. // Uniquement pour les utilisateurs de base. req.body.UserId=user.id; if(req.body.QuestionnaireId && user.status === "user") await answerCtrl.saveAnswerToQuestionnaire(req.body); else if(req.body.GroupId && user.status === "user") await answerCtrl.saveAnswerToGroup(req.body); res.status(200).json( { userId: user.id, status: user.status, connexionTime: loginTime, token: jwt.sign({ userId: user.id }, config.tokenPrivateKey, { expiresIn: loginTime }) }); } } } } next(); } catch(e) { next(e); } } // Reçoit les données du formulaire de connexion avec demande de recevoir un lien de connexion. exports.getLoginLink = async (req, res, next) => { try { // Est-ce qu'un compte existe pour l'adresse e-mail envoyée ? const emailSend=tool.trimIfNotNull(req.body.email); const userDatas=await searchUserByEmail(emailSend); if(!userDatas) res.status(404).json({ errors: [txt.emailNotFound] }); else if(userDatas.User.status!=="user") // seuls les utilisateurs de base peuvent se connecter de cette façon. res.status(403).json({ errors: [txtGeneral.notAllowed] }); else { // Est-ce ce compte a déjà été validé par l'utilisateur ? Si non, on lui envoie un nouveau lien de validation. if(!userDatas.Subscription) { await sendValidationLink(userDatas.User); res.status(401).json({ errors: [txt.needValidationToLogin] }); } else { const token=jwt.sign({ userId:userDatas.User.id, keepConnected:req.body.keepConnected }, config.tokenPrivateKey, { expiresIn: config.tokenLoginLinkTimeInHours }); const mapMail = { USER_NAME: userDatas.User.name, LINK_URL : config.siteUrl+"/"+configTpl.loginLinkPage+token }; const mailDatas= { mailSubject: txt.mailLoginLinkSubject, mailPreheader: txt.mailLoginLinkSubject, mailTitle: txt.mailLoginLinkSubject, mailHeaderLinkUrl: config.siteUrl+"/"+configTpl.loginLinkPage+token, mailHeaderLinkTxt: txt.mailLoginLinkTxt, mailMainContent: tool.replaceAll(txt.mailLoginLinkBodyHTML, mapMail), linksCTA: [{ url:config.siteUrl+"/"+configTpl.loginLinkPage+token, txt:txt.mailLoginLinkTxt }], mailRecipientAddress: userDatas.User.email } await toolMail.sendMail(userDatas.User.smtp, userDatas.User.email, txt.mailLoginLinkSubject, tool.replaceAll(txt.mailLoginLinkBodyTxt, mapMail), "", mailDatas); res.status(200).json({ message: txt.mailLoginLinkMessage.replace("*TIMING*", config.tokenLoginLinkTimeInHours) }); } } next(); } catch(e) { next(e); } } exports.checkLoginLink = async (req, res, next) => { try { const db = require("../models/index"); const userDatas = await checkTokenUser(req.body.t); if(userDatas.User.status !== "user") res.status(403).json({ errors: [txtGeneral.notAllowed] }); else if(userDatas.Subscription) { const now=new Date(); const timeDifference=req.body.timeDifference; db["User"].update({ connectedAt: now, timeDifference: timeDifference }, { where: { id : userDatas.User.id }, limit:1 }); creaUserJson(userDatas.User.id); let loginTime=config.tokenConnexionMinTimeInHours; if(userDatas.decodedToken.keepConnected===true) loginTime=config.tokenConnexionMaxTimeInDays; // Si l'utilisateur a répondu à un quiz (ou groupe de quizs) avant de se connecter, on enregistre son résultat : req.body.UserId=userDatas.User.id; if(req.body.QuestionnaireId) await answerCtrl.saveAnswerToQuestionnaire(req.body); else if(req.body.GroupId) await answerCtrl.saveAnswerToGroup(req.body); res.status(200).json( { userId: userDatas.User.id, connexionTime: loginTime, token: jwt.sign({ userId: userDatas.User.id }, config.tokenPrivateKey, { expiresIn: loginTime }) }); } else // ne devrait pas être possible... { await sendValidationLink(userDatas.User); res.status(401).json({ errors: [txt.needValidationToLogin] }); } next(); } catch(e) { next(e); } } exports.modify = async (req, res, next) => { try { const db = require("../models/index"); if(req.body.newPassword && req.body.newPassword.length < config.passwordMinLength) res.status(400).json({ errors: txt.needLongPassWord.replace("MIN_LENGTH", config.passwordMinLength) }); else { if(req.connectedUser.User.status==="user") { await Promise.all([ db["User"].update({ ...req.body }, { where: { id : req.connectedUser.User.id } , fields: ["name", "language", "timeDifference"], limit:1 }), db["Subscription"].update({ ...req.body }, { where: { UserId : req.connectedUser.User.id }, fields: ["receiptDays"], limit:1 }) ]); creaUserJson(req.connectedUser.User.id); const messageRetour=[txt.updatedOkMessage]; if(req.body.newPassword || (req.body.email != req.connectedUser.User.email)) { const newLogin={ userId: req.connectedUser.User.id }; req.body.email=tool.trimIfNotNull(req.body.email); if(req.body.email != req.connectedUser.User.email) { if (! /[A-Za-z0-9_.-]+@[A-Za-z0-9_.-]+\.[A-Za-z]{2,6}/.test(req.body.email)) messageRetour.push(txt.updatedNeedGoodEmail); else { const emailFree=await searchUserByEmail(req.body.email); if(emailFree!==false) messageRetour.push(txt.updatedNeedUniqueEmail.replace("NEW_EMAIL", req.body.email)); else newLogin.email=req.body.email; } } if(req.body.newPassword) newLogin.password=await bcrypt.hash(req.body.newPassword, config.bcryptSaltRounds); if(newLogin.email || newLogin.password) { const token=jwt.sign(newLogin, config.tokenPrivateKey, { expiresIn: config.tokenLoginChangingTimeInHours }); const mapMail = { USER_NAME: req.body.name, LINK_URL : config.siteUrl+"/"+configTpl.newLoginLinkPage+token }; const mailDatas= { mailSubject: txt.mailUpdateLoginSubject, mailPreheader: txt.mailUpdateLoginSubject, mailTitle: txt.mailUpdateLoginSubject, mailHeaderLinkUrl: config.siteUrl+"/"+configTpl.newLoginLinkPage+token, mailHeaderLinkTxt: txt.mailUpdateLoginLinkTxt, mailMainContent: tool.replaceAll(txt.mailUpdateLoginBodyHTML, mapMail), linksCTA: [{ url:config.siteUrl+"/"+configTpl.newLoginLinkPage+token, txt:txt.mailUpdateLoginLinkTxt }], mailRecipientAddress: req.body.email } await toolMail.sendMail(req.connectedUser.User.smtp, req.body.email, txt.mailUpdateLoginSubject, tool.replaceAll(txt.mailUpdateLoginBodyTxt, mapMail), "", mailDatas); messageRetour.push(txt.mailUpdateLoginLinkMessage.replace("NEW_EMAIL", req.body.email)); } } res.status(200).json({ message: messageRetour }); } else { let userToUpdating=await searchUserById(req.params.id); if(!userToUpdating || !userToUpdating.Subscription) res.status(400).json({ errors: [txt.updatedNeedValidatedUser] }); else { const messageRetour=[txtGeneral.updateOkMessage]; if(req.body.newPassword) req.body.password=await bcrypt.hash(req.body.newPassword, config.bcryptSaltRounds); if(req.body.newGodfatherId!=undefined) { const godFather=searchIdGodfather(req.body.newGodfatherId); if(empty(godFather)) messageRetour.push(txt.updatedNeedGoodGodfather); else req.body.GodfatherId=godFather.id; } switch(req.connectedUser.User.status) { case "admin": await Promise.all([ db["User"].update({ ...req.body }, { where: { id : req.params.id }, limit:1 }), db["Subscription"].update({ ...req.body }, { where: { UserId : req.params.id }, limit:1 }) ]); break; case "manager": await Promise.all([ db["User"].update({ ...req.body }, { where: { id : req.params.id }, fields: ["name", "email", "password", "language", "adminComments", "smtp", "GodfatherId"], limit:1 }), db["Subscription"].update({ ...req.body }, { where: { UserId : req.params.id }, fields: ["numberOfDays", "receiptDays"], limit:1 }) ]); break; case "creator": await Promise.all([ db["User"].update({ ...req.body }, { where: { id : req.params.id } , fields: ["name", "email", "password", "language", "adminComments"], limit:1 }), db["Subscription"].update({ ...req.body }, { where: { UserId : req.params.id }, fields: ["numberOfDays", "receiptDays"], limit:1 }) ]); break; default: throw { message: txtGeneral.serverError }; } await creaUserJson(req.params.id);// besoin d'attendre car utiliser pour rafraîchir l'affichage res.status(200).json({ message: messageRetour }); } } } next(); } catch(e) { const returnAPI=toolError.returnSequelize(e); if(returnAPI.messages) { res.status(returnAPI.status).json({ errors : returnAPI.messages }); next(); } else next(e); } } exports.checkNewLoginLink = async (req, res, next) => { try { const db = require("../models/index"); const userDatas=await checkTokenUser(req.params.token); if(userDatas) { if(userDatas.User.id!==req.connectedUser.User.id) res.status(401).json({ errors: [txtGeneral.notAllowed] }); else { await db["User"].update({ ...userDatas.decodedToken }, { where: { id : userDatas.User.id } , fields: ["email", "password"], limit:1 }); creaUserJson(userDatas.User.id); res.status(200).json({ message: txt.mailUpdateLoginOkMessage }); } } else res.status(404).json({ errors: [txtGeneral.notAllowed] }); next(); } catch(e) { next(e); } } exports.create = async (req, res, next) => { try { const db = require("../models/index"); const connectedUser=req.connectedUser; if(connectedUser.User.status==="user") res.status(403).json({ errors: [txtGeneral.notAllowed] }); else { if(!tool.isEmpty(req.body.GodfatherId) && ! await searchUserById(req.body.GodfatherId)) res.status(400).json({ errors: [txt.updatedFailedGodfatherNotFound] }); else { req.body.password=await bcrypt.hash(req.body.password, config.bcryptSaltRounds); if(req.body.GodfatherId==="") req.body.GodfatherId=null; let user; switch(connectedUser.User.status) { case "admin": user=await db["User"].create({ ...req.body }); req.body.UserId=user.id; await db["Subscription"].create({ ...req.body }); break; case "manager": user=await db["User"].create({ ...req.body }, { fields: ["name", "email", "password", "language", "adminComments", "smtp", "GodfatherId"] }); req.body.UserId=user.id; await db["Subscription"].create({ ...req.body }, { fields: ["numberOfDays", "receiptDays", "UserId"] }); break; case "creator": user=await db["User"].create({ ...req.body }, { fields: ["name", "email", "password", "language", "adminComments"] }); req.body.UserId=user.id; await db["Subscription"].create({ ...req.body }, { fields: ["numberOfDays", "receiptDays", "UserId"] }); break; default: throw { message: [txtGeneral.serverError] }; } creaUserJson(req.body.UserId); res.status(201).json({ message: [txt.creationOkMessage], id:req.body.UserId }); } } next(); } catch(e) { const returnAPI=toolError.returnSequelize(e); if(returnAPI.messages) { res.status(returnAPI.status).json({ errors : [returnAPI.messages] }); next(); } else next(e); } } exports.validate = async (req, res, next) => { try { const db = require("../models/index"); const connectedUser=req.connectedUser; if(["admin", "manager"].indexOf(connectedUser.User.status) === -1) res.status(403).json({ errors: [txtGeneral.notAllowed] }); else { const userToValidating=await searchUserById(req.params.id); if(!userToValidating) res.status(404).json({ errors: [txt.notFound] }); else if(userToValidating.Subscription) res.status(400).json({ errors: [txt.validationAlreadyMessageAdmin] }); else { await db["Subscription"].create({ numberOfDays: config.freeAccountTimingInDays, UserId: req.params.id }); creaUserJson(req.params.id); res.status(200).json({ message: [txt.validationMessageAdmin] }); } } } catch(e) { const returnAPI=toolError.returnSequelize(e); if(returnAPI.messages) { res.status(returnAPI.status).json({ errors : returnAPI.messages }); next(); } else next(e); } } exports.delete = async (req, res, next) => { try { const db = require("../models/index"); const connectedUser=req.connectedUser; if(connectedUser.User.status==="user") { const userDatas=await searchUserById(connectedUser.User.id); const token=jwt.sign({ userId: connectedUser.User.id }, config.tokenPrivateKey, { expiresIn: config.tokenDeleteUserTimeInHours }); const mapMail = { USER_NAME: userDatas.User.name, LINK_URL : config.siteUrl+"/"+configTpl.deleteLinkPage+token }; const mailDatas= { mailSubject: txt.mailDeleteSubject, mailPreheader: txt.mailDeleteSubject, mailTitle: txt.mailDeleteSubject, mailHeaderLinkUrl: config.siteUrl+"/"+configTpl.deleteLinkPage+token, mailHeaderLinkTxt: txt.mailDeleteLinkTxt, mailMainContent: tool.replaceAll(txt.mailDeleteBodyHTML, mapMail), linksCTA: [{ url:config.siteUrl+"/"+configTpl.deleteLinkPage+token, txt:txt.mailDeleteLinkTxt }], mailRecipientAddress: connectedUser.User.email } await toolMail.sendMail(connectedUser.User.smtp, connectedUser.User.email, txt.mailDeleteSubject, tool.replaceAll(txt.mailDeleteBodyTxt, mapMail), "", mailDatas); res.status(200).json({ message: txt.mailDeleteLinkMessage }); } else if (["admin","manager","creator"].indexOf(connectedUser.User.status) !== -1) { const userDeleted=await searchUserById(req.params.id); if(!userDeleted) throw { message: txt.notFound }; const nb=await db["User"].destroy({ where: { id : req.params.id }, limit:1 }); if(nb===1) { await toolFile.deleteJSON(config.dirCacheUsers, req.params.id); toolFile.deleteJSON(config.dirCacheUsersQuestionnaires+"/without", req.params.id); toolFile.deleteJSON(config.dirCacheUsersQuestionnaires+"/answers", req.params.id); toolFile.deleteJSON(config.dirCacheUsersQuestionnaires+"/answers", "stats"+req.params.id); let now=new Date(), wasValided=false, wasPremium=false; if(userDeleted.Subscription) { wasValided=true; if(userDeleted.Subscription.numberOfDay > config.freeAccountTimingInDays) wasPremium=true; } db["UserDeleted"].create({ createdAt: userDeleted.User.createdAt, deletedAt: now, wasValided: wasValided, wasPremium: wasPremium }); res.status(200).json({ message: [txt.deleteOkMessage] }); } else { res.status(400).json({ errors: txtGeneral.serverError }); throw { message: txt.deleteFailMessage+req.params.id }; } } next(); } catch(e) { next(e); } } exports.checkDeleteLink = async (req, res, next) => { try { const db = require("../models/index"); const connectedUser=req.connectedUser; const userDatas=await checkTokenUser(req.params.token); if(userDatas) { if(connectedUser.User.id!=userDatas.User.id) res.status(403).json({ errors: [txtGeneral.notAllowed] }); else { const nb=await db["User"].destroy({ where: { id : connectedUser.User.id }, limit:1 }); if(nb===1) { await toolFile.deleteJSON(config.dirCacheUsers, connectedUser.User.id); res.status(200).json({ message: txt.mailDeleteLinkOkMessage }); toolFile.deleteJSON(config.dirCacheUsersQuestionnaires+"/without", connectedUser.User.id); toolFile.deleteJSON(config.dirCacheUsersQuestionnaires+"/answers", connectedUser.User.id); toolFile.deleteJSON(config.dirCacheUsersQuestionnaires+"/answers", "stats"+connectedUser.User.id); const now=new Date(); wasPremium=false; if(userDatas.Subscription.numberOfDay > config.freeAccountTimingInDays) wasPremium=true; db["UserDeleted"].create({ createdAt: userDatas.User.createdAt, deletedAt: now, wasValided:true, wasPremium: wasPremium }); } else res.status(400).json({ errors: [txt.mailDeleteLinkAlreadyMessage] }); } } else res.status(400).json({ errors: [txt.mailDeleteLinkFailMessage] }); next(); } catch(e) { next(e); } } exports.getOneUserById = async (req, res, next) => { try { const connectedUser=req.connectedUser; if(connectedUser.User.status==="user") { if(connectedUser.User.id!=req.params.id) res.status(403).json({ errors: txtGeneral.notAllowed }); else { const datas=await searchUserById(connectedUser.User.id); if(datas) res.status(200).json(datas); else res.status(404).json({ message:txt.notFound }); } } else if (["admin","manager","creator"].indexOf(connectedUser.User.status) !== -1) {// dans le cas des "creator" il faudra peut-être limité l'accès à "ses" utilisateurs ? const datas=await searchUserById(req.params.id); if(datas) res.status(200).json(datas); else res.status(404).json({ message:txt.notFound }); } next(); } catch(e) { next(e); } } exports.getOneUserGodChilds = async (req, res, next) => { try { const db = require("../models/index"); const connectedUser=req.connectedUser; let godchilds; if(["admin","manager","creator"].indexOf(connectedUser.User.status) === -1) godchilds=await db["User"].findAll({ where: { GodfatherId: connectedUser.User.id }, attributes: ["id", "name", "email"] }); else godchilds=await db["User"].findAll({ where: { GodfatherId: req.params.id }, attributes: ["id", "name", "email"] }); res.status(200).json(godchilds); next(); } catch(e) { next(e); } } exports.searchUsers = async (req, res, next) => { try { const connectedUser=req.connectedUser; if(["admin", "manager", "creator"].indexOf(connectedUser.User.status) === -1) res.status(403).json({ errors: [txtGeneral.notAllowed] }); else { const db = require("../models/index"); const Users=await db.sequelize.query("SELECT `id`,`name`,`email` FROM `Users` WHERE `name` LIKE :search OR `adminComments` LIKE :search OR `email` LIKE :search OR `id` = :id", { replacements: { search: "%"+req.body.search+"%", id: req.body.search }, type: QueryTypes.SELECT }); res.status(200).json(Users); } next(); } catch(e) { next(e); } } // Retourne des statistiques concernant les utilisateurs // Utile tableau de bord gestionnaires exports.getStats= async (req, res, next) => { try { let stats=await getStatsUsers(); stats.Answers=await answerCtrl.getStatsAnswers(); stats.Subscriptions=await subscriptionCtrl.getStatsSubscriptions(); res.status(200).json(stats); next(); } catch(e) { next(e); } } // CRONS // Supprime les fichiers stockant les erreurs de connexion ayant expirés exports.deleteLoginFail = async (req, res, next) => { try { const fileExpiration=new Date().getTime()-config.loginFailTimeInMinutes*60*1000; const deleteFiles = await toolFile.deleteOldFilesInDirectory(config.dirTmpLogin, fileExpiration); res.status(200).json(deleteFiles); next(); } catch(e) { next(e); } } // Suppression des fichiers pour des utilisateurs n'existant plus exports.deleteJsonFiles= async (req, res, next) => { try { const db = require("../models/index"); const users=await db["User"].findAll({ attributes: ["id"] }); let saveFiles=[]; for(let i in users) { saveFiles.push(users[i].id+".json"); saveFiles.push("stats"+users[i].id+".json"); } const deleteFiles = await Promise.all([ toolFile.deleteFilesInDirectory(configUsers.dirCacheUsers, saveFiles), toolFile.deleteFilesInDirectory(configUsers.dirCacheUsersWithoutAnswers, saveFiles), toolFile.deleteFilesInDirectory(configUsers.dirCacheUsersAnswers, saveFiles) ]); res.status(200).json(deleteFiles); next(); } catch(e) { next(e); } } // Suppression des comptes n'ayant pas été validé passé un certain délai exports.deleteUnvalided= async (req, res, next) => { try { const db = require("../models/index"); const nowTS=Date.now(); const timeExpiration=(nowTS-parseInt(config.tokenSignupValidationTimeInHours,10)*3600*1000)/1000; const userUnvalided= await db.sequelize.query("SELECT createdAt FROM `Users` WHERE UNIX_TIMESTAMP(createdAt) < "+timeExpiration+" AND `id` NOT IN (SELECT `UserId` FROM `Subscriptions`)", { type: QueryTypes.SELECT }); if(userUnvalided.length!==0) { const [results, metadata] = await db.sequelize.query("DELETE FROM `Users` WHERE UNIX_TIMESTAMP(createdAt) < "+timeExpiration+" AND `id` NOT IN (SELECT `UserId` FROM `Subscriptions`)"); const now=new Date(); for(let i in userUnvalided) await db["UserDeleted"].create({ createdAt: userUnvalided[i].createdAt, deletedAt: now, wasValided: false }); console.log(metadata.affectedRows+txt.cronDeleteUnvalidedUsersMessage); } res.status(200).json(true); next(); } catch(e) { next(e); } } // Suppression des comptes dont l'abonnement a expiré et ne s'étant pas connecté depuis à certains temps exports.deleteInactiveAccounts= async(req, res, next) => { try { const db = require("../models/index"); const usersInactive= await db.sequelize.query("SELECT createdAt FROM `Users` WHERE status='user' AND (ADDDATE(`connectedAt`, "+config.inactiveAccountTimeToDeleteInDays+") < NOW() OR `connectedAt` IS NULL) AND `id` IN (SELECT `UserId` FROM `Subscriptions` WHERE ADDDATE(`createdAt`, `numberOfDays`)< NOW())", { type: QueryTypes.SELECT }); if(usersInactive.length!==0) { const [results, metadata] = await db.sequelize.query("DELETE FROM `Users` WHERE (ADDDATE(`connectedAt`, "+config.inactiveAccountTimeToDeleteInDays+") < NOW() OR `connectedAt` IS NULL) AND status='user' AND `id` IN (SELECT `UserId` FROM `Subscriptions` WHERE ADDDATE(`createdAt`, `numberOfDays`)< NOW())"); if(metadata.affectedRows!==0) res.message=metadata.affectedRows+txt.deleteInactiveUsersMessage; const now=new Date(); for(let i in usersInactive) await db["UserDeleted"].create({ createdAt: usersInactive[i].createdAt, deletedAt: now, wasValided: true }); } res.status(200).json(true); next(); } catch(e) { next(e); } } // FONCTIONS UTILITAIRES // Création du fichier des données de l'utilisateur + son abonnement et ses pauses const creaUserJson = async (id) => { id=tool.trimIfNotNull(id); if(id===null) return false; const db = require("../models/index"); const User=await db["User"].findByPk(id, { attributes: { exclude: ['password'] } }); if(User) { let datas={ User }; const Subscription=await db["Subscription"].findOne({ where: { UserId: id } }); if(Subscription) // pas de cache pour utilisateurs non validés { datas.Subscription=Subscription; const Pauses=await db["Pause"].findAll({ where: { SubscriptionId: Subscription.id } }); if(Pauses) datas.Pauses=Pauses; await toolFile.createJSON(config.dirCacheUsers, id, datas); } return datas; } else return false; } exports.creaUserJson = creaUserJson; const searchUserById = async (id) => { id=tool.trimIfNotNull(id); if(id===null) return false; const user=await toolFile.readJSON(config.dirCacheUsers, id); if(user) return user; else return await creaUserJson(id); } exports.searchUserById = searchUserById; const searchUserByEmail = async (email) => { const db = require("../models/index"); const emailSend=tool.trimIfNotNull(email); const userEmail=await db["User"].findOne({ attributes: ["id"], where: { email : emailSend } }); if(userEmail) return await searchUserById(userEmail.id);// permet de récupérer les autres infos (Subscription, etc.) else return false; } // Recherche le parrain dont le "code" fourni peut être l'identifiant préfixé ou bien l'adresse e-mail const searchIdGodfather = async (code) => { let godfatherInfos=""; code=tool.trimIfNotNull(code); if(code===null) return false; else if(code.indexOf("@")!==-1) // tester en premier, car une adresse peut débuter par le préfixe de l'appli... godfatherInfos=await searchUserByEmail(code); else if (code.startsWith(config.beginCodeGodfather)) godfatherInfos=await searchUserById(code.substring(config.beginCodeGodfather.length)); if(godfatherInfos.Subscription && godfatherInfos.User.status==="user") // le parrain doit avoir validé son compte et doit être un simple "user" return godfatherInfos.User; else return null; } // Envoi le lien permettant au nouvel utilisateur de valider son compte const sendValidationLink = async (user) => { const token=jwt.sign({ userId: user.id }, config.tokenPrivateKey, { expiresIn: config.tokenSignupValidationTimeInHours }); const mapMail = { USER_NAME: user.name, LINK_URL: config.siteUrl+"/"+configTpl.validationLinkPage+token, }; const mailDatas= { mailSubject: txt.mailValidationLinkSubject, mailPreheader: txt.mailValidationLinkSubject, mailTitle: txt.mailValidationLinkSubject, mailHeaderLinkUrl: config.siteUrl+"/"+configTpl.validationLinkPage+token, mailHeaderLinkTxt: txt.mailValidationLinkTxt, mailMainContent: tool.replaceAll(txt.mailValidationLinkSBodyHTML, mapMail), linksCTA: [{ url:config.siteUrl+"/"+configTpl.validationLinkPage+token, txt:txt.mailValidationLinkTxt }], mailRecipientAddress: user.email } await toolMail.sendMail(0, user.email, txt.mailValidationLinkSubject, tool.replaceAll(txt.mailValidationLinkSBodyTxt, mapMail), "", mailDatas); return true; } // Permet de vérifier un token de connexion : est-il valide et est-ce qu'il correspond à un utilisateur ? // Si oui, on peut aussi enregistrer une nouvelle connexion pour l'utilisateur (une fois / jour) const checkTokenUser = async (token) => { const db = require("../models/index"); const decodedToken=jwt.verify(token, config.tokenPrivateKey); const userId=decodedToken.userId; const datas=await searchUserById(userId); if(datas.User) { const now=new Date(); const nowTS=Date.now() const lastConnection = Date.parse(datas.User.connectedAt); if(lastConnection+24*3600*1000 < nowTS) // une fois par jour suffit. { await db["User"].update({ connectedAt: now }, { where: { id : userId }, limit:1 }); creaUserJson(userId); } datas.decodedToken=decodedToken; return datas; } else return false; } exports.checkTokenUser = checkTokenUser; // Stats sur les créations de compte, suppression.. durant les dernières 24H ou depuis le début const getStatsUsers = async () => { const db = require("../models/index"); const getNewUsers24H = await db.sequelize.query("SELECT `id` FROM `Users` WHERE `createdAt` > ADDDATE(NOW(), -1)", { type: QueryTypes.SELECT }); const getNewUsersTot = await db.sequelize.query("SELECT `id` FROM `Users`", { type: QueryTypes.SELECT }); const getDeletedUsers24H = await db.sequelize.query("SELECT `id` FROM `UserDeleteds` WHERE `deletedAt` > ADDDATE(NOW(), -1)", { type: QueryTypes.SELECT }); const getDeletedUsersTot = await db.sequelize.query("SELECT `id` FROM `UserDeleteds`", { type: QueryTypes.SELECT }); const getDeletedUsersWasValided = await db.sequelize.query("SELECT `id` FROM `UserDeleteds` WHERE `wasValided`= 1", { type: QueryTypes.SELECT }); const getDeletedUsersTotWasPremium = await db.sequelize.query("SELECT `id` FROM `UserDeleteds` WHERE `wasPremium`= 1", { type: QueryTypes.SELECT }); if(getNewUsers24H && getNewUsersTot && getDeletedUsers24H && getDeletedUsersWasValided && getDeletedUsersTotWasPremium && getDeletedUsersTot ) { const stats = { nbNewUsers24H : getNewUsers24H.length, nbNewUsersTot : getNewUsersTot.length, nbDeletedUsers24H : getDeletedUsers24H.length, nbDeletedUsersTot : getDeletedUsersTot.length, nbDeletedUsersWasValided : getDeletedUsersWasValided.length, nbDeletedUsersTotWasPremium : getDeletedUsersTotWasPremium.length } return stats; } else return false; } exports.getStatsUsers = getStatsUsers;