const { Op, QueryTypes } = require("sequelize");// pour certaines requêtes sql const pug = require("pug"); var striptags = require("striptags"); const config = require("../config/main.js"); const configTags = require("../config/tags.js"); const tool = require("../tools/main"); const toolError = require("../tools/error"); const toolFile = require("../tools/file"); const questionnaireCtrl = require("./questionnaire"); const txt = require("../lang/"+config.adminLang+"/tag"); const txtGeneral = require("../lang/"+config.adminLang+"/general"); const txtQuestionnaire = require("../lang/"+config.adminLang+"/questionnaire"); const txtIllustration = require("../lang/"+config.adminLang+"/illustration"); // Actualise le classement d'un questionnaire suivant les tags envoyés exports.checkTags = async (req, res, next) => { try { if(req.body.QuestionnaireId==undefined) throw { message: txt.neededParams }; const tagsCurrent=await getUsedTagsQuestionnaire(req.body.QuestionnaireId); if(tagsCurrent===false) throw { message: txt.tagsForQuestionnaireNotFound }; const tagsReceived=req.body.classification.split(",");// ! peut être vide si pas/plus de classement souhaité for(i in tagsReceived) tagsReceived[i]=tagsReceived[i].trim().toLowerCase();// ! gestion de la casse différente pour JS, pas pour Mysql // les tags jusqu'ici associés sont-ils toujours utilisés ? let deleteLink; for (i in tagsCurrent) { if(tagsReceived.indexOf(tagsCurrent[i].name.toLowerCase())===-1) deleteLink=await unlinkTagQuestionnaire(tagsCurrent[i].id, req.body.QuestionnaireId); } // parmis les tags envoyés, certains sont-ils nouveaux pour ce questionnaire ? let findTag=false, creaLink; for(i in tagsReceived) { for(j in tagsCurrent) { if(tagsCurrent[j].name.toLowerCase()===tagsReceived[i]) { findTag=true; break; } } if(!findTag && tagsReceived[i]!=="") // revoir : remettre les majuscules lors de l'enregistrement ? { creaLink=await linkTagQuestionnaire(tagsReceived[i], req.body.QuestionnaireId); if(creaLink!==true) throw creaLink;// nécessaire pour retourner les erreurs du modèle (mais uniquement "tag trop long" possible) } findTag=false; } await questionnaireCtrl.creaQuestionnaireJson(req.body.QuestionnaireId);// attendre avant de répondre pour que cela pris en compte au réaffichage if(req.method=="PUT") res.status(200).json({ message: txtGeneral.updateOkMessage }); else if(req.method=="POST") res.status(201).json({ message: txtGeneral.addOkMessage, id:req.body.QuestionnaireId }); next(); } catch(e) { const returnAPI=toolError.returnSequelize(e); if(returnAPI.messages) { res.status(returnAPI.status).json({ errors : returnAPI.messages }); next(); } else next(e); } } // Retourne la liste des tags déjà connus débutant par l'expression donnée : exports.getTagsBeginningBy = async (req, res, next) => { try { let tags=await getAllTags(), tagsOk=[], search=req.body.search.trim().toLowerCase(), item; if(search.length >= 2) { for(i in tags) { item=tags[i].name.toLowerCase();// restera le problème des accents if(item.startsWith(search)) tagsOk.push(tags[i]); } } res.status(200).json(tagsOk); next(); } catch(e) { next(e); } } // Fais suite à la même fonction dans questionnaire.js // Va récupérer la liste des tags utilisés pour classer au moins un questionnaire publié // Puis regénère les fichiers HTML pour chacun de ces tags exports.HTMLRegenerate= async (req, res, next) => { try { const tagsUsed=await getUsedTags(); for(let i in tagsUsed) await creaQuestionnairesTagJson(tagsUsed[i].id);// provoque la regénération du json + du html res.status(200).json({ message: res.messageToNext.replace("#NB2", tagsUsed.length) }); res.messageToNext=null; next(); } catch(e) { next(e); } } // UTILITAIRES // Créer la liste de tous les tags présents dans la base de données const creaAllTagsJson = async () => { const db = require("../models/index"); const tags=await db["Tag"].findAll(); await toolFile.createJSON(configTags.dirCacheTags, "all", tags); return tags; } // Retourne la liste de tous les tags const getAllTags = async () => { const tags=await toolFile.readJSON(configTags.dirCacheTags, "all"); if(tags) return tags; else return await creaAllTagsJson(); } // Créer la liste de tous tags utilisés pour classer au moins un quiz publié const creaUsedTagsJson = async () => { const db = require("../models/index"); const tags = await db.sequelize.query("SELECT DISTINCT `Tags`.`id`,`Tags`.`name`,`Tags`.`slug` FROM `Tags` INNER JOIN `QuestionnaireClassifications` INNER JOIN `Questionnaires` WHERE `Tags`.`id`=`QuestionnaireClassifications`.`TagId` AND `QuestionnaireClassifications`.`QuestionnaireId`=`Questionnaires`.`id` AND `Questionnaires`.`isPublished`=true ORDER BY `name` ASC", { type: QueryTypes.SELECT , model: db["Tag"], mapToModel: true }); await toolFile.createJSON(configTags.dirCacheTags, "used", tags); return tags; } exports.creaUsedTagsJson = creaUsedTagsJson;// utile pour actualiser en cas de publication/dépublication d'un quiz // Retourne la liste des tags utilisés const getUsedTags = async () => { const tags=await toolFile.readJSON(configTags.dirCacheTags, "used"); if(tags) return tags; else return await creaUsedTagsJson(); } exports.getUsedTags = getUsedTags; // Retourne la liste des tags d'un questionnaire avec leurs noms, slugs, etc. const getUsedTagsQuestionnaire = async (id) => { id=tool.trimIfNotNull(id); if(id===null) return false; const questionnaire=await questionnaireCtrl.searchQuestionnaireById(id); if(!questionnaire) throw { message: txtQuestionnaire.notFound }; else { const allTags=await getAllTags(); let tagsQuestionnaire=[]; for(i in questionnaire.Tags) { for(j in allTags) { if(allTags[j].id===questionnaire.Tags[i].TagId) { tagsQuestionnaire.push(allTags[j]); break; } } } return tagsQuestionnaire; } } exports.getTagsQuestionnaire = getUsedTagsQuestionnaire; // Créer la liste complète des questionnaires publiés, classés par un tag const creaQuestionnairesTagJson = async (id) => { id=tool.trimIfNotNull(id); if(id===null) return false; const db = require("../models/index"); const questionnaires = await db.sequelize.query("SELECT id FROM `Questionnaires` INNER JOIN `QuestionnaireClassifications` ON `Questionnaires`.`id`=`QuestionnaireClassifications`.`QuestionnaireId` AND `Questionnaires`.`isPublished`=1 AND `QuestionnaireClassifications`.`TagId`=:id ORDER BY `Questionnaires`.`publishingAt`", { replacements: { id: id }, type: QueryTypes.SELECT , model: db["Questionnaire"], mapToModel: true }); await toolFile.createJSON(configTags.dirCacheTags, "liste-"+id, questionnaires);// le supprimer si liste vide ? creaUsedTagsJson(); creaQuestionnairesTagHTML(id, questionnaires);// pas await, car potentiellement long ! return questionnaires; } exports.creaQuestionnairesTagJson = creaQuestionnairesTagJson; const creaQuestionnairesTagHTML = async (id, Questionnaires) => { id=tool.trimIfNotNull(id); if(id===null || Questionnaires===null) return false; const tag=await searchTagById(id); if(Questionnaires.length===0) { // plus aucun quiz classé ici. Il faudrait idéalement envoyer des erreurs 404/410, etc. // revoir aussi l'intérêt ou non de supprimer les pages suivantes, sachant qu'elles ne sont pas indexables ? ou les rendre dynamiques ? await toolFile.deleteFile(configTags.dirHTMLTags, tag.slug+".html"); return true; } const compiledFunction = pug.compileFile("./views/"+config.theme+"/tag.pug"); const configTpl = require("../views/"+config.theme+"/config/"+config.availableLangs[0]+".js"); const pageDatas= { config: config, configTpl: configTpl, tool: tool, striptags: striptags, txtGeneral : txtGeneral, txtQuestionnaire: txtQuestionnaire, txtIllustration: txtIllustration, pageLang: config.adminLang, metaDescription: config.siteName+" : "+txt.tagMetaDescription+tag.name, pageTitle: config.siteName+" - "+tag.name, contentTitle: config.siteName+" - "+tag.name, tagInfos: tag, linkCanonical: config.siteUrl+"/"+configTags.dirWebTags+"/"+tag.slug+".html" } const nbPages=Math.ceil(Questionnaires.length / configTpl.maxQuestionnairesByPage); pageDatas.nbPages=nbPages; let debut=0, fin, questionnairesPage, questionnairesInfos=[], html, url; for (let i = 1; i <= nbPages; i++) { let questionnairesPage = Questionnaires.slice(debut, debut+configTpl.maxQuestionnairesByPage); for(let j in questionnairesPage) questionnairesInfos.push(await questionnaireCtrl.searchQuestionnaireById(questionnairesPage[j].id)); pageDatas.questionnaires=questionnairesInfos; pageDatas.page=i; url=tag.slug; if(i!==1) { url=url+"-"+i; pageDatas.metaRobots="noindex,follow"; pageDatas.linkCanonical=null; } html=await compiledFunction(pageDatas); await toolFile.createHTML(configTags.dirHTMLTags, url, html); debut+=configTpl.maxQuestionnairesByPage; questionnairesInfos=[]; } return true; } // Retourne un tag, si il existe const searchTagByName = async (name) => { name=tool.trimIfNotNull(name); if(name===null) return false; const db = require("../models/index"); const tag=await db["Tag"].findOne({ where: { name: name } }); // utile de faire en sql pour les problèmes de majuscules / minuscules if(tag) return tag; else return false; } const searchTagById = async (id) => { id=tool.trimIfNotNull(id); if(id===null) return false; const db = require("../models/index"); const tag=await db["Tag"].findByPk(id); if(tag) return tag; else return false; } // Supprime l'association entre un tag et un questionnaire + actualise la liste des questionnaires pour le tag concerné // La mise à jour du json/HTML du questionnaire est appelée par le contrôleur appelant cette fonction const unlinkTagQuestionnaire = async (tagId, questionnaireId) => { const db = require("../models/index"); await db["QuestionnaireClassification"].destroy( { where: { TagId: tagId, QuestionnaireId : questionnaireId }, limit:1 }); creaQuestionnairesTagJson(tagId);// peut être lent ! return true; } // Créer l'association entre un tag et un questionnaire + actualise la liste des questionnaires / tag // La mise à jour du json/HTML du questionnaire est appelée par le contrôleur appelant cette fonction const linkTagQuestionnaire = async (tagName, questionnaireId) => { const db = require("../models/index"); // ce tag est-il nouveau ? let tagLinked=await searchTagByName(tagName); if(tagLinked===false) { tagLinked=await db["Tag"].create({ name: tagName, slug: null }, { fields: ["name", "slug"] });// "slug : null" pour laisser le modèle le générer creaAllTagsJson(); } if(tagLinked) { await db["QuestionnaireClassification"].create({ TagId: tagLinked.id, QuestionnaireId: questionnaireId }); creaQuestionnairesTagJson(tagLinked.id);// peut être lent ! } return true; }