1126 lines
48 KiB
JavaScript
1126 lines
48 KiB
JavaScript
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; |