Merge pull request #6 from Divlo/v2.1

v2.1

README.md

@@ -5,10 +5,9 @@
 </p>
 
 <p align="center">
+  <a href="https://gitmoji.carloscuesta.me/"><img src="https://camo.githubusercontent.com/2a4924a23bd9ef18afe793f4999b1b9ec474e48f/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6769746d6f6a692d253230f09f989c253230f09f988d2d4646444436372e7376673f7374796c653d666c61742d737175617265" alt="Gitmoji"/></a>
+  <a href="https://standardjs.com"><img alt="JavaScript Style Guide" src="https://img.shields.io/badge/code_style-standard-brightgreen.svg"/></a>
   <a href="./LICENSE"><img src="https://img.shields.io/badge/licence-MIT-blue.svg" alt="Licence MIT"/></a>
-  <img src="https://img.shields.io/github/repo-size/Divlo/FunctionProject" alt="Repo Size">
-  <a href="https://github.com/Divlo/FunctionProject/commits/master"><img src="https://img.shields.io/github/commit-activity/m/Divlo/FunctionProject" alt="Commit Activity"></a>
-  <a href="https://github.com/Divlo/FunctionProject/graphs/contributors"><img src="https://img.shields.io/github/contributors/Divlo/FunctionProject" alt="Contributors"></a>
   <img src="https://img.shields.io/github/stars/Divlo/FunctionProject?style=social" alt="Stars">
   <br/> <br/>
   <a href="https://function.divlo.fr/"><img src="https://raw.githubusercontent.com/Divlo/FunctionProject/master/.github/FunctionProject.png" alt="FunctionProject" /></a>
@@ -24,7 +23,7 @@ Si vous aimez le projet, vous pouvez aider à **le faire connaître** en utilisa
 
 Les dernières versions publiées : [https://github.com/Divlo/FunctionProject/releases](https://github.com/Divlo/FunctionProject/releases)
 
-Le projet est disponible sur [function.divlo.fr](https://function.divlo.fr/) (actuellement en version 2.0).
+Le projet est disponible sur [function.divlo.fr](https://function.divlo.fr/) (actuellement en version 2.1).
 
 ## 🚀 Open Source
 
@@ -66,16 +65,21 @@ Vous devrez ensuite configurer l'API en créant un fichier `.env` à la racine d
 Dans deux terminals séparés :
 
 - Lancer le front-end en allant dans `/website`
+
 ```sh
 npm run dev # front-end lancé sur http://localhost:3000
 ```
+
 - Lancer l'api en allant dans `/api`
+
 ```sh
 npm run dev # API lancé sur http://localhost:8080
 ```
 
 Enjoy! 😃
 
+[![JavaScript Style Guide](https://cdn.rawgit.com/standard/standard/master/badge.svg)](https://github.com/standard/standard)
+
 ## 📄 Licence
 
 Ce projet est sous licence MIT - voir le fichier [LICENSE](./LICENSE) pour plus de détails.

api/.gitignore

@@ -18,6 +18,7 @@
 .env.development.local
 .env.test.local
 .env.production.local
+.env.production
 /temp
 /assets/images/
 

api/app.js

@@ -1,83 +1,94 @@
 /* Modules */
-require('dotenv').config();
+require('dotenv').config()
-const path            = require('path');
+const path = require('path')
-const express         = require('express');
+const express = require('express')
-const helmet          = require('helmet');
+const helmet = require('helmet')
-const cors            = require('cors');
+const cors = require('cors')
-const morgan          = require('morgan');
+const morgan = require('morgan')
-const redirectToHTTPS = require('express-http-to-https').redirectToHTTPS;
+const { redirectToHTTPS } = require('express-http-to-https')
 
 /* Files Imports & Variables */
-const sequelize     = require('./assets/utils/database');
+const sequelize = require('./assets/utils/database')
-const { PORT }      = require('./assets/config/config');
+const { PORT } = require('./assets/config/config')
-const errorHandling = require('./assets/utils/errorHandling');
+const errorHandling = require('./assets/utils/errorHandling')
-const isAuth        = require('./middlewares/isAuth');
+const isAuth = require('./middlewares/isAuth')
-const isAdmin       = require('./middlewares/isAdmin');
+const isAdmin = require('./middlewares/isAdmin')
-const app           = express();
+const app = express()
 
 /* Middlewares */
-app.use(helmet());
+app.use(helmet())
-app.use(cors());
+app.use(cors())
-app.use(morgan('dev'));
+app.use(morgan('dev'))
-app.use(express.json());
+app.use(express.json())
-app.use(redirectToHTTPS([/localhost:(\d{4})/]));
+app.use(redirectToHTTPS([/localhost:(\d{4})/]))
 
 /* Routes */
-app.use('/images', express.static(path.join(__dirname, "assets", "images")));
+app.use('/images', express.static(path.join(__dirname, 'assets', 'images')))
-app.use('/functions', require('./routes/functions'));
+app.use('/functions', require('./routes/functions'))
-app.use('/categories', require('./routes/categories'));
+app.use('/categories', require('./routes/categories'))
-app.use('/users', require('./routes/users'));
+app.use('/users', require('./routes/users'))
-app.use('/admin', isAuth, isAdmin, require('./routes/admin'));
+app.use('/admin', isAuth, isAdmin, require('./routes/admin'))
-app.use('/favorites', require('./routes/favorites'));
+app.use('/favorites', require('./routes/favorites'))
-app.use('/comments', require('./routes/comments'));
+app.use('/comments', require('./routes/comments'))
-app.use('/quotes', require('./routes/quotes'));
+app.use('/quotes', require('./routes/quotes'))
-app.use('/tasks', require('./routes/tasks'));
+app.use('/tasks', require('./routes/tasks'))
+app.use('/links', require('./routes/links_shortener'))
 
 /* Errors Handling */
-app.use((_req, _res, next) => errorHandling(next, { statusCode: 404, message: "La route n'existe pas!" })); // 404
+app.use((_req, _res, next) =>
+  errorHandling(next, { statusCode: 404, message: "La route n'existe pas!" })
+) // 404
 app.use((error, _req, res, _next) => {
-    console.log(error);
+  console.log(error)
-    const { statusCode, message } = error;
+  const { statusCode, message } = error
-    return res.status(statusCode || 500).json({ message });
+  return res.status(statusCode || 500).json({ message })
-});
+})
 
 /* Database Relations */
-const Functions  = require('./models/functions');
+const Functions = require('./models/functions')
-const Categories = require('./models/categories');
+const Categories = require('./models/categories')
-const Users      = require('./models/users');
+const Users = require('./models/users')
-const Favorites  = require('./models/favorites');
+const Favorites = require('./models/favorites')
-const Comments   = require('./models/comments');
+const Comments = require('./models/comments')
-const Quotes     = require('./models/quotes');
+const Quotes = require('./models/quotes')
-const Tasks      = require('./models/tasks');
+const Tasks = require('./models/tasks')
+const ShortLinks = require('./models/short_links')
 
 // A function has a category
-Categories.hasOne(Functions, { constraints: true, onDelete: 'CASCADE'});
+Categories.hasOne(Functions, { constraints: true, onDelete: 'CASCADE' })
-Functions.belongsTo(Categories);
+Functions.belongsTo(Categories)
 
 // Users can have favorites functions
-Users.hasMany(Favorites);
+Users.hasMany(Favorites)
-Favorites.belongsTo(Users, { constraints: false });
+Favorites.belongsTo(Users, { constraints: false })
-Functions.hasMany(Favorites);
+Functions.hasMany(Favorites)
-Favorites.belongsTo(Functions, { constraints: false });
+Favorites.belongsTo(Functions, { constraints: false })
 
 // Users can post comments on functions
-Users.hasMany(Comments);
+Users.hasMany(Comments)
-Comments.belongsTo(Users, { constraints: false });
+Comments.belongsTo(Users, { constraints: false })
-Functions.hasMany(Comments);
+Functions.hasMany(Comments)
-Comments.belongsTo(Functions, { constraints: false });
+Comments.belongsTo(Functions, { constraints: false })
 
 // Users can suggest new quotes
-Users.hasMany(Quotes);
+Users.hasMany(Quotes)
-Quotes.belongsTo(Users, { constraints: false });
+Quotes.belongsTo(Users, { constraints: false })
 
 // Users can have tasks
-Users.hasMany(Tasks);
+Users.hasMany(Tasks)
-Tasks.belongsTo(Users, { constraints: false });
+Tasks.belongsTo(Users, { constraints: false })
+
+// Users can have links
+Users.hasMany(ShortLinks)
+ShortLinks.belongsTo(Users, { constraints: false })
 
 /* Server */
 // sequelize.sync({ force: true })
-sequelize.sync()
+sequelize
+  .sync()
   .then(() => {
-        app.listen(PORT, () =>  console.log('\x1b[36m%s\x1b[0m', `Started on port ${PORT}.`));
+    app.listen(PORT, () =>
+      console.log('\x1b[36m%s\x1b[0m', `Started on port ${PORT}.`)
+    )
   })
-    .catch((error) => console.log(error));
+  .catch(error => console.log(error))

api/assets/config/config.js

@@ -21,6 +21,6 @@ const config = {
     }
   },
   TOKEN_LIFE: '1 week'
-};
+}
 
-module.exports = config;
+module.exports = config

api/assets/config/emails.js

@@ -26,16 +26,24 @@ exports.emailQuoteTemplate = (isValid, quote, frontendLink) => `
                                             <tr>
                                                 <td align="left" valign="top" style="line-height:150%;font-family:Helvetica;font-size:14px;color:rgb(222, 222, 222);padding:30px;box-shadow: 0px 0px 6px 6px rgba(0, 0, 0, .25);border: 1px solid black;border-radius: 1rem;">
                                                     <h2 style="font-size:22px;line-height:28px;margin:0 0 12px 0;">
-                                                        La citation que vous avez proposée a été ${(isValid) ? "validée" : "supprimée"}.
+                                                        La citation que vous avez proposée a été ${
+                                                          isValid
+                                                            ? 'validée'
+                                                            : 'supprimée'
+                                                        }.
                                                     </h2>
                                                     <p style="margin: 0 0 12px 0;">
                                                         <a style="color: #ffd800;" href="${frontendLink}/functions/randomQuote">Lien vers la fonction randomQuote de FunctionProject.</a>
                                                     </p>
-                                                    ${(!isValid) ? `
+                                                    ${
+                                                      !isValid
+                                                        ? `
                                                         <p style="margin: 0 0 12px 0;">
                                                             Si votre citation a été supprimée et vous pensez que c'est une erreur, contactez-moi à cette adresse email : <a style="color: #ffd800;" href="mailto:contact@divlo.fr">contact@divlo.fr</a>.
                                                         </p>
-                                                    ` : ""}
+                                                    `
+                                                        : ''
+                                                    }
                                                     <div>
                                                         <p style="padding:0 0 10px 0">
                                                             La citation en question : <br/>
@@ -57,7 +65,7 @@ exports.emailQuoteTemplate = (isValid, quote, frontendLink) => `
         </tbody>
     </table>
 </center>
-`;
+`
 
 exports.emailUserTemplate = (subtitle, buttonText, url, footerText) => `
 <center>
@@ -107,4 +115,4 @@ exports.emailUserTemplate = (subtitle, buttonText, url, footerText) => `
         </tbody>
     </table>
 </center>
-`;
+`

api/assets/config/errors.js

@@ -10,9 +10,9 @@ const errors = {
   },
 
   requiredFields: {
-        message: "Vous devez remplir tous les champs...",
+    message: 'Vous devez remplir tous les champs...',
     statusCode: 400
   }
-};
+}
 
-module.exports = errors;
+module.exports = errors

api/assets/config/transporter.js

@@ -1,6 +1,6 @@
-const nodemailer     = require('nodemailer');
+const nodemailer = require('nodemailer')
-const { EMAIL_INFO } = require('./config');
+const { EMAIL_INFO } = require('./config')
 
-const transporter = nodemailer.createTransport(EMAIL_INFO);
+const transporter = nodemailer.createTransport(EMAIL_INFO)
 
-module.exports = transporter;
+module.exports = transporter

api/assets/functions/functionObject.js

@@ -1,20 +1,19 @@
-const { randomNumberOutput }          = require('./main/randomNumber');
+const { randomNumberOutput } = require('./main/randomNumber')
-const convertRomanArabicNumbersOutput = require('./main/convertRomanArabicNumbers');
+const convertRomanArabicNumbersOutput = require('./main/convertRomanArabicNumbers')
-const convertDistanceOutput           = require('./main/convertDistance');
+const convertDistanceOutput = require('./main/convertDistance')
-const convertTemperatureOutput        = require('./main/convertTemperature');
+const convertTemperatureOutput = require('./main/convertTemperature')
-const armstrongNumberOutput           = require('./main/armstrongNumber');
+const armstrongNumberOutput = require('./main/armstrongNumber')
-const weatherRequestOutput            = require('./main/weatherRequest');
+const weatherRequestOutput = require('./main/weatherRequest')
-const convertCurrencyOutput           = require('./main/convertCurrency');
+const convertCurrencyOutput = require('./main/convertCurrency')
-const calculateAgeOutput              = require('./main/calculateAge');
+const calculateAgeOutput = require('./main/calculateAge')
-const heapAlgorithmOutput             = require('./main/heapAlgorithm');
+const heapAlgorithmOutput = require('./main/heapAlgorithm')
-const convertEncodingOutput           = require('./main/convertEncoding');
+const convertEncodingOutput = require('./main/convertEncoding')
-const randomQuote                     = require('./main/randomQuote');
+const randomQuote = require('./main/randomQuote')
-const linkShortener                   = require('./main/linkShortener');
+const rightPriceOutput = require('./main/rightPrice')
-const rightPriceOutput                = require('./main/rightPrice');
+const isPalindromeOutput = require('./main/isPalindrome')
-const isPalindromeOutput              = require('./main/isPalindrome');
+const findLongestWordOutput = require('./main/findLongestWord')
-const findLongestWordOutput           = require('./main/findLongestWord');
+const fibonacciOutput = require('./main/fibonacci')
-const fibonacciOutput                 = require('./main/fibonacci');
+const sortArrayOutput = require('./main/sortArray')
-const sortArrayOutput                 = require('./main/sortArray');
 
 const functionObject = {
   randomNumber: randomNumberOutput,
@@ -28,17 +27,16 @@ const functionObject = {
   heapAlgorithm: heapAlgorithmOutput,
   convertEncoding: convertEncodingOutput,
   randomQuote: randomQuote,
-    linkShortener            : linkShortener,
   rightPrice: rightPriceOutput,
   isPalindrome: isPalindromeOutput,
   findLongestWord: findLongestWordOutput,
   fibonacci: fibonacciOutput,
-    sortArray                : sortArrayOutput,
+  sortArray: sortArrayOutput
-};
+}
 
 // Choisi la fonction à exécuter
 function functionToExecute (option) {
-    return functionObject[option];
+  return functionObject[option]
 }
 
-module.exports = functionToExecute;
+module.exports = functionToExecute

api/assets/functions/main/armstrongNumber.js

@@ -1,6 +1,6 @@
-const errorHandling      = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields } = require('../../config/errors');
+const { requiredFields } = require('../../config/errors')
-const formatNumberResult = require('../secondary/formatNumberResult');
+const formatNumberResult = require('../secondary/formatNumberResult')
 
 /**
  * @description Vérifie si un nombre fait partie des nombres d'Armstrong.
@@ -9,38 +9,51 @@ const formatNumberResult = require('../secondary/formatNumberResult');
  * @examples armstrongNumber(153) → 153 est un nombre d'Armstrong, car  1<sup>3</sup> + 5<sup>3</sup> + 3<sup>3</sup> = 153.
  */
 function armstrongNumber (number) {
-    let numberString = number.toString();
+  const numberString = number.toString()
-    let numberStringLength = numberString.length;
+  const numberStringLength = numberString.length
 
-    let result = 0;
+  let result = 0
-    let resultString = "";
+  let resultString = ''
   for (let index = 0; index < numberStringLength; index++) {
-        result = result + parseInt(numberString[index]) ** numberStringLength;
+    result = result + parseInt(numberString[index]) ** numberStringLength
-        resultString = resultString + " + " + numberString[index] + "<sup>" + numberStringLength + "</sup>";
+    resultString =
+      resultString +
+      ' + ' +
+      numberString[index] +
+      '<sup>' +
+      numberStringLength +
+      '</sup>'
   }
 
-    const formattedNumber = formatNumberResult(number);
+  const formattedNumber = formatNumberResult(number)
-    const isArmstrongNumber = (result === number); 
+  const isArmstrongNumber = result === number
   return {
     isArmstrongNumber,
-        resultHTML: `<p>${formattedNumber} ${isArmstrongNumber ? "est" : "n'est pas"} un nombre d'Armstrong, car ${resultString.slice(2)} = ${formatNumberResult(result)}.</p>`
+    resultHTML: `<p>${formattedNumber} ${
+      isArmstrongNumber ? 'est' : "n'est pas"
+    } un nombre d'Armstrong, car ${resultString.slice(
+      2
+    )} = ${formatNumberResult(result)}.</p>`
   }
 }
 
 /* OUTPUTS */
-module.exports = armstrongNumberOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { number } = argsObject;
+  let { number } = argsObject
 
   // S'il n'y a pas les champs obligatoire
-    if (!(number)) {
+  if (!number) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Si ce n'est pas un nombre
-    number = parseInt(number);
+  number = parseInt(number)
   if (isNaN(number) || number <= 0) {
-        return errorHandling(next, { message: "Veuillez rentré un nombre valide.", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'Veuillez rentré un nombre valide.',
+      statusCode: 400
+    })
   }
 
-    return res.status(200).json(armstrongNumber(number));
+  return res.status(200).json(armstrongNumber(number))
 }

api/assets/functions/main/calculateAge.js

@@ -1,50 +1,60 @@
-const errorHandling      = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const moment             = require('moment');
+const moment = require('moment')
-const { requiredFields } = require('../../config/errors');
+const { requiredFields } = require('../../config/errors')
 
-function calculateAge(currentDate, { birthDateDay, birthDateMonth, birthDateYear }) {
+function calculateAge (
-    const day   = currentDate.getDate();
+  currentDate,
-    const month = currentDate.getMonth();
+  { birthDateDay, birthDateMonth, birthDateYear }
-    const currentDateMoment = moment([currentDate.getFullYear(), month, day]);
+) {
-    const birthDateMoment   = moment([birthDateYear, birthDateMonth, birthDateDay]);
+  const day = currentDate.getDate()
+  const month = currentDate.getMonth()
+  const currentDateMoment = moment([currentDate.getFullYear(), month, day])
+  const birthDateMoment = moment([birthDateYear, birthDateMonth, birthDateDay])
 
   // Calcule l'âge - Moment.js
-    const ageYears = currentDateMoment.diff(birthDateMoment, 'year');
+  const ageYears = currentDateMoment.diff(birthDateMoment, 'year')
-    birthDateMoment.add(ageYears, 'years');
+  birthDateMoment.add(ageYears, 'years')
-    const ageMonths = currentDateMoment.diff(birthDateMoment, 'months');
+  const ageMonths = currentDateMoment.diff(birthDateMoment, 'months')
-    birthDateMoment.add(ageMonths, 'months');
+  birthDateMoment.add(ageMonths, 'months')
-    const ageDays = currentDateMoment.diff(birthDateMoment, 'days');
+  const ageDays = currentDateMoment.diff(birthDateMoment, 'days')
 
-    const isBirthday = (birthDateDay === day && birthDateMonth === month); 
+  const isBirthday = birthDateDay === day && birthDateMonth === month
-    return { ageYears, ageMonths, ageDays, isBirthday };
+  return { ageYears, ageMonths, ageDays, isBirthday }
 }
 
 /* OUTPUTS */
-module.exports = calculateAgeOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { birthDate } = argsObject;
+  const { birthDate } = argsObject
 
   // S'il n'y a pas les champs obligatoire
-    if (!(birthDate)) {
+  if (!birthDate) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
-    const birthDateDay   = parseInt(birthDate.substring(0, 2));
+  const birthDateDay = parseInt(birthDate.substring(0, 2))
-    const birthDateMonth = parseInt((birthDate.substring(3, 5)) - 1);
+  const birthDateMonth = parseInt(birthDate.substring(3, 5) - 1)
-    const birthDateYear  = parseInt(birthDate.substring(6, 10));
+  const birthDateYear = parseInt(birthDate.substring(6, 10))
 
   // Si ce n'est pas une date valide
-    const currentDate     = new Date();
+  const currentDate = new Date()
-    const birthDateObject = new Date(birthDateYear, birthDateMonth, birthDateDay);
+  const birthDateObject = new Date(birthDateYear, birthDateMonth, birthDateDay)
-    const result          = calculateAge(currentDate, { birthDateYear, birthDateMonth, birthDateDay });
+  const result = calculateAge(currentDate, {
-    if ((currentDate < birthDateObject) || isNaN(result.ageYears)) {
+    birthDateYear,
-        return errorHandling(next, { message: "Veuillez rentré une date valide...", statusCode: 400 });
+    birthDateMonth,
+    birthDateDay
+  })
+  if (currentDate < birthDateObject || isNaN(result.ageYears)) {
+    return errorHandling(next, {
+      message: 'Veuillez rentré une date valide...',
+      statusCode: 400
+    })
   }
 
-    let resultHTML;
+  let resultHTML
   if (result.isBirthday) {
-        resultHTML = `<p>Vous avez ${result.ageYears} ans. Joyeux Anniversaire! 🥳</p>`;
+    resultHTML = `<p>Vous avez ${result.ageYears} ans. Joyeux Anniversaire! 🥳</p>`
   } else {
-        resultHTML = `<p>Vous avez ${result.ageYears} ans, ${result.ageMonths} mois et ${result.ageDays} jour(s).</p>`;
+    resultHTML = `<p>Vous avez ${result.ageYears} ans, ${result.ageMonths} mois et ${result.ageDays} jour(s).</p>`
   }
-    return res.status(200).json({ ...result, resultHTML });
+  return res.status(200).json({ ...result, resultHTML })
 }

api/assets/functions/main/convertCurrency.js

@@ -1,37 +1,53 @@
-const axios              = require('axios');
+const axios = require('axios')
-const errorHandling      = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields } = require('../../config/errors');
+const { requiredFields } = require('../../config/errors')
-const formatNumberResult = require('../secondary/formatNumberResult');
+const formatNumberResult = require('../secondary/formatNumberResult')
 
 /* OUTPUTS */
-module.exports = convertCurrencyOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { number, baseCurrency, finalCurrency } = argsObject;
+  let { number, baseCurrency, finalCurrency } = argsObject
 
   // S'il n'y a pas les champs obligatoire
   if (!(number && baseCurrency && finalCurrency)) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Si ce n'est pas un nombre
-    number = parseFloat(number);
+  number = parseFloat(number)
   if (isNaN(number)) {
-        return  errorHandling(next, { message: "Veuillez rentré un nombre valide.", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'Veuillez rentré un nombre valide.',
+      statusCode: 400
+    })
   }
 
-    axios.get(`https://api.exchangeratesapi.io/latest?base=${baseCurrency}`)
+  axios
-        .then((response) => {
+    .get(`https://api.exchangeratesapi.io/latest?base=${baseCurrency}`)
-            const rate = response.data.rates[finalCurrency];
+    .then(response => {
+      const rate = response.data.rates[finalCurrency]
       if (!rate) {
-                return errorHandling(next, { message: "La devise n'existe pas.", statusCode: 404 });
+        return errorHandling(next, {
-            }
+          message: "La devise n'existe pas.",
-            const result     = rate * number;
+          statusCode: 404
-            const dateObject = new Date(response.data.date);
-            const year       = dateObject.getFullYear();
-            const day        = ('0'+(dateObject.getDate())).slice(-2);
-            const month      = ('0'+(dateObject.getMonth()+1)).slice(-2);
-            const date       = `${day}/${month}/${year}`;
-            const resultHTML = `<p>${formatNumberResult(number)} ${response.data.base} = ${formatNumberResult(result.toFixed(2))} ${finalCurrency}</p><p>Dernier rafraîchissement du taux d'échange : ${date}</p>`;
-            return res.status(200).json({ date, result, resultHTML });
         })
-        .catch(() => errorHandling(next, { message: "La devise n'existe pas.", statusCode: 404 }));
+      }
+      const result = rate * number
+      const dateObject = new Date(response.data.date)
+      const year = dateObject.getFullYear()
+      const day = ('0' + dateObject.getDate()).slice(-2)
+      const month = ('0' + (dateObject.getMonth() + 1)).slice(-2)
+      const date = `${day}/${month}/${year}`
+      const resultHTML = `<p>${formatNumberResult(number)} ${
+        response.data.base
+      } = ${formatNumberResult(
+        result.toFixed(2)
+      )} ${finalCurrency}</p><p>Dernier rafraîchissement du taux d'échange : ${date}</p>`
+      return res.status(200).json({ date, result, resultHTML })
+    })
+    .catch(() =>
+      errorHandling(next, {
+        message: "La devise n'existe pas.",
+        statusCode: 404
+      })
+    )
 }

api/assets/functions/main/convertDistance.js

@@ -1,8 +1,34 @@
-const errorHandling                    = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields, generalError } = require('../../config/errors');
+const { requiredFields, generalError } = require('../../config/errors')
-const formatNumberResult               = require('../secondary/formatNumberResult');
+const formatNumberResult = require('../secondary/formatNumberResult')
 
-const correspondancesDistance = ["pm", null, null, "nm", null, null, "µm", null, null, "mm", "cm", "dm", "m", "dam", "hm", "km", null, null, "Mm", null, null, "Gm", null, null, "Tm"];
+const correspondancesDistance = [
+  'pm',
+  null,
+  null,
+  'nm',
+  null,
+  null,
+  'µm',
+  null,
+  null,
+  'mm',
+  'cm',
+  'dm',
+  'm',
+  'dam',
+  'hm',
+  'km',
+  null,
+  null,
+  'Mm',
+  null,
+  null,
+  'Gm',
+  null,
+  null,
+  'Tm'
+]
 
 /**
  * @description Convertis la longueur (distance) avec les unités allant de picomètre au Téramètre.
@@ -14,38 +40,45 @@ const correspondancesDistance = ["pm", null, null, "nm", null, null, "µm", null
  * @examples convertDistance(500, 'cm', 'm') → { resultNumber: 5, resultString: "5 m" }
  */
 function convertDistance (firstValue, unitFirstValue, unitFinalValue) {
-    const index1 = correspondancesDistance.indexOf(unitFirstValue); 
+  const index1 = correspondancesDistance.indexOf(unitFirstValue)
-    const index2 = correspondancesDistance.indexOf(unitFinalValue);
+  const index2 = correspondancesDistance.indexOf(unitFinalValue)
   if (index1 !== -1 && index2 !== -1) {
-        const difference = index1 - index2; 
+    const difference = index1 - index2
-        const result = firstValue * Math.pow(10, difference);
+    const result = firstValue * Math.pow(10, difference)
     return {
       result,
-            resultHTML: `<p>${formatNumberResult(firstValue)} ${unitFirstValue} = ${formatNumberResult(result)} ${unitFinalValue}</p>`
+      resultHTML: `<p>${formatNumberResult(
-        };
+        firstValue
+      )} ${unitFirstValue} = ${formatNumberResult(
+        result
+      )} ${unitFinalValue}</p>`
     }
-    return false;
+  }
+  return false
 }
 
 /* OUTPUTS */
-module.exports = convertDistanceOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { number, numberUnit, finalUnit } = argsObject;
+  let { number, numberUnit, finalUnit } = argsObject
 
   // S'il n'y a pas les champs obligatoire
   if (!(number && numberUnit && finalUnit)) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Si ce n'est pas un nombre
-    number = parseFloat(number);
+  number = parseFloat(number)
   if (isNaN(number)) {
-        return errorHandling(next, { message: "Veuillez rentré un nombre valide.", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'Veuillez rentré un nombre valide.',
+      statusCode: 400
+    })
   }
 
-    const result = convertDistance(number, numberUnit, finalUnit);
+  const result = convertDistance(number, numberUnit, finalUnit)
   if (!result) {
-        return errorHandling(next, generalError);
+    return errorHandling(next, generalError)
   }
 
-    return res.status(200).json(result);
+  return res.status(200).json(result)
 }

api/assets/functions/main/convertEncoding.js

@@ -1,5 +1,5 @@
-const errorHandling                    = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields, generalError } = require('../../config/errors');
+const { requiredFields, generalError } = require('../../config/errors')
 
 /**
  * @description Convertis un nombre décimal en binaire.
@@ -8,11 +8,11 @@ const { requiredFields, generalError } = require('../../config/errors');
  * @examples decimalToBinary('2') → '10'
  */
 function decimalToBinary (value) {
-    value = Number(value);
+  value = Number(value)
   if (isNaN(value)) {
-        return false;
+    return false
   } else {
-        return value.toString(2);
+    return value.toString(2)
   }
 }
 
@@ -23,11 +23,11 @@ function decimalToBinary(value) {
  * @examples binaryToDecimal('10') → 2
  */
 function binaryToDecimal (value) {
-    const result = parseInt(Number(value), 2);
+  const result = parseInt(Number(value), 2)
   if (isNaN(result)) {
-        return false;
+    return false
   } else {
-        return result;
+    return result
   }
 }
 
@@ -38,11 +38,11 @@ function binaryToDecimal(value) {
  * @examples decimalToHexadecimal('15') → 'F'
  */
 function decimalToHexadecimal (value) {
-    value = Number(value);
+  value = Number(value)
   if (isNaN(value)) {
-        return false;
+    return false
   } else {
-        return value.toString(16).toUpperCase();
+    return value.toString(16).toUpperCase()
   }
 }
 
@@ -53,11 +53,11 @@ function decimalToHexadecimal(value) {
  * @examples hexadecimalToDecimal('F') → 15
  */
 function hexadecimalToDecimal (value) {
-    const result = parseInt(value, 16);
+  const result = parseInt(value, 16)
   if (isNaN(result)) {
-        return false;
+    return false
   } else {
-        return result;
+    return result
   }
 }
 
@@ -68,12 +68,14 @@ function hexadecimalToDecimal(value) {
  * @examples binaryToHexadecimal('1111') → 'F'
  */
 function binaryToHexadecimal (value) {
-    value = Number(value);
+  value = Number(value)
-    value = parseInt(value, 2);
+  value = parseInt(value, 2)
   if (isNaN(value)) {
-        return false;
+    return false
   } else {
-        return parseInt(value).toString(16).toUpperCase();
+    return parseInt(value)
+      .toString(16)
+      .toUpperCase()
   }
 }
 
@@ -84,11 +86,11 @@ function binaryToHexadecimal(value) {
  * @examples hexadecimalToBinary('F') → '1111'
  */
 function hexadecimalToBinary (value) {
-    value = parseInt(value, 16);
+  value = parseInt(value, 16)
   if (isNaN(value)) {
-        return false;
+    return false
   } else {
-        return parseInt(value).toString(2);
+    return parseInt(value).toString(2)
   }
 }
 
@@ -102,14 +104,13 @@ function hexadecimalToBinary(value) {
  */
 function textToNumberUnicode (string) {
   try {
-        let resultat = "";
+    let resultat = ''
-        for (let index in string) {
+    for (const index in string) {
-          resultat = resultat + string.codePointAt(index) + " ";
+      resultat = resultat + string.codePointAt(index) + ' '
     }
-        return resultat;
+    return resultat
-    }
+  } catch (error) {
-    catch(error) {
+    return false
-        return false;
   }
 }
 
@@ -121,15 +122,14 @@ function textToNumberUnicode(string) {
  */
 function numberUnicodeToText (string) {
   try {
-        const array = string.split(" ");
+    const array = string.split(' ')
-        let resultat = "";
+    let resultat = ''
-        for (let index in array) {
+    for (const index in array) {
-            resultat += String.fromCodePoint(parseInt(array[index]).toString());
+      resultat += String.fromCodePoint(parseInt(array[index]).toString())
     }
-        return resultat;
+    return resultat
-    }
+  } catch (error) {
-    catch(error) {
+    return false
-        return false;
   }
 }
 
@@ -141,16 +141,21 @@ function numberUnicodeToText(string) {
  */
 function textToBinary (s) {
   try {
-        s = unescape( encodeURIComponent(s));
+    s = unescape(encodeURIComponent(s))
-        let chr, i = 0, l = s.length, out = '';
+    let chr
+    let i = 0
+    const l = s.length
+    let out = ''
     for (; i < l; i++) {
-            chr = s.charCodeAt( i ).toString(2);
+      chr = s.charCodeAt(i).toString(2)
-            while(chr.length % 8 != 0 ){ chr = '0' + chr; }
+      while (chr.length % 8 !== 0) {
-            out += chr;
+        chr = '0' + chr
       }
-        return out.replace(/(\d{8})/g, '$1 ').replace(/(^\s+|\s+$)/,'');
+      out += chr
+    }
+    return out.replace(/(\d{8})/g, '$1 ').replace(/(^\s+|\s+$)/, '')
   } catch (error) {
-        return false;
+    return false
   }
 }
 
@@ -163,14 +168,17 @@ function textToBinary(s) {
 function binaryToText (s) {
   try {
     s = s.replace(/\s/g, '')
-        let i = 0, l = s.length, chr, out = '';
+    let i = 0
+    const l = s.length
+    let chr
+    let out = ''
     for (; i < l; i += 8) {
-            chr = parseInt( s.substr(i, 8 ), 2).toString(16);
+      chr = parseInt(s.substr(i, 8), 2).toString(16)
-            out += '%' + ((chr.length % 2 == 0) ? chr : '0' + chr);
+      out += '%' + (chr.length % 2 === 0 ? chr : '0' + chr)
     }
-        return decodeURIComponent(out);
+    return decodeURIComponent(out)
   } catch (error) {
-        return false;
+    return false
   }
 }
 
@@ -182,17 +190,19 @@ function binaryToText(s){
  */
 function textToHexadecimal (s) {
   try {
-        s = unescape( encodeURIComponent( s ) );
+    s = unescape(encodeURIComponent(s))
-        let chr, i = 0, l = s.length, out = '';
+    let chr
+    let i = 0
+    const l = s.length
+    let out = ''
     for (; i < l; i++) {
-            chr = s.charCodeAt( i ).toString( 16 );
+      chr = s.charCodeAt(i).toString(16)
-            out += ( chr.length % 2 == 0 ) ? chr : '0' + chr;
+      out += chr.length % 2 === 0 ? chr : '0' + chr
-            out += " ";
+      out += ' '
     }
-        return out.toUpperCase();
+    return out.toUpperCase()
-    }
+  } catch (error) {
-    catch (error) {
+    return false
-        return false;
   }
 }
 
@@ -204,39 +214,55 @@ function textToHexadecimal (s) {
  */
 function hexadecimalToText (s) {
   try {
-        s = s.replace(/\s/g,'');
+    s = s.replace(/\s/g, '')
-        return decodeURIComponent( s.replace( /../g, '%$&' ) );
+    return decodeURIComponent(s.replace(/../g, '%$&'))
-    }
+  } catch (error) {
-	catch (error) {
+    return false
-        return false;
   }
 }
 
 /* OUTPUTS */
-const convertEncoding = { decimalToBinary, binaryToDecimal, decimalToHexadecimal, hexadecimalToDecimal, binaryToHexadecimal, hexadecimalToBinary, textToNumberUnicode, numberUnicodeToText, textToBinary, binaryToText, textToHexadecimal, hexadecimalToText };
+const convertEncoding = {
+  decimalToBinary,
+  binaryToDecimal,
+  decimalToHexadecimal,
+  hexadecimalToDecimal,
+  binaryToHexadecimal,
+  hexadecimalToBinary,
+  textToNumberUnicode,
+  numberUnicodeToText,
+  textToBinary,
+  binaryToText,
+  textToHexadecimal,
+  hexadecimalToText
+}
 function executeFunction (option, value) {
-    return convertEncoding[option](value);
+  return convertEncoding[option](value)
 }
 
-module.exports = convertEncodingOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { value, functionName } = argsObject;
+  const { value, functionName } = argsObject
 
   // S'il n'y a pas les champs obligatoire
   if (!(value && functionName)) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Si la fonction n'existe pas
+  // eslint-disable-next-line
   if (!convertEncoding.hasOwnProperty(functionName)) {
-        return errorHandling(next, { message: "Cette conversion n'existe pas.", statusCode: 400 });
+    return errorHandling(next, {
+      message: "Cette conversion n'existe pas.",
+      statusCode: 400
+    })
   }
 
-    const result = executeFunction(functionName, value);
+  const result = executeFunction(functionName, value)
 
   // Mauvaise valeur entrée
   if (!result) {
-        return errorHandling(next, generalError);
+    return errorHandling(next, generalError)
   }
 
-    return res.status(200).json({ result, resultHTML: `<p>${result}</p>` });
+  return res.status(200).json({ result, resultHTML: `<p>${result}</p>` })
 }

api/assets/functions/main/convertRomanArabicNumbers.js

@@ -1,23 +1,23 @@
-const errorHandling                    = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields, generalError } = require('../../config/errors');
+const { requiredFields, generalError } = require('../../config/errors')
-const formatNumberResult               = require('../secondary/formatNumberResult');
+const formatNumberResult = require('../secondary/formatNumberResult')
 
 /* Variable pour convertRomanArabicNumbers */
 const correspondancesRomainArabe = [
-    [1000, "M"],
+  [1000, 'M'],
-    [900, "CM"],
+  [900, 'CM'],
-    [500, "D"],
+  [500, 'D'],
-    [400, "CD"],
+  [400, 'CD'],
-    [100, "C"],
+  [100, 'C'],
-    [90, "XC"],
+  [90, 'XC'],
-    [50, "L"],
+  [50, 'L'],
-    [40, "XL"],
+  [40, 'XL'],
-    [10, "X"],
+  [10, 'X'],
-    [9, "IX"],
+  [9, 'IX'],
-    [5, "V"],
+  [5, 'V'],
-    [4, "IV"],
+  [4, 'IV'],
-    [1, "I"],
+  [1, 'I']
-];
+]
 
 /**
  * @description Convertis un nombre arabe en nombre romain.
@@ -27,20 +27,20 @@ const correspondancesRomainArabe = [
  */
 function convertArabicToRoman (nombre) {
   // Initialisation de la variable qui va contenir le résultat de la conversion
-    let chiffresRomains = "";
+  let chiffresRomains = ''
 
   function extraireChiffreRomain (valeurLettre, lettres) {
     while (nombre >= valeurLettre) {
-            chiffresRomains = chiffresRomains + lettres;
+      chiffresRomains = chiffresRomains + lettres
-            nombre = nombre - valeurLettre;
+      nombre = nombre - valeurLettre
     }
   }
 
   correspondancesRomainArabe.forEach(correspondance => {
-        extraireChiffreRomain(correspondance[0], correspondance[1]);
+    extraireChiffreRomain(correspondance[0], correspondance[1])
-    });
+  })
 
-    return chiffresRomains;
+  return chiffresRomains
 }
 
 /**
@@ -50,74 +50,94 @@ function convertArabicToRoman(nombre) {
  * @example convertRomanToArabic('XXIV') → 24
  */
 function convertRomanToArabic (string) {
-    let result = 0;
+  let result = 0
-    correspondancesRomainArabe.forEach((correspondance) => {        
+  correspondancesRomainArabe.forEach(correspondance => {
     while (string.indexOf(correspondance[1]) === 0) {
       // Ajout de la valeur décimale au résultat
-            result += correspondance[0];
+      result += correspondance[0]
       // Supprimer la lettre romaine correspondante du début
-            string = string.replace(correspondance[1], '');
+      string = string.replace(correspondance[1], '')
     }
-    });
+  })
-    if (string != '') {
+  if (string !== '') {
-        result = 0;
+    result = 0
   }
-    return result;
+  return result
 }
 
 /* OUTPUTS */
 const convertRomanToArabicOutput = ({ res, next }, number) => {
-    
   // S'il n'y a pas les champs obligatoire
-    if (!(number)) {
+  if (!number) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Formate le paramètre
-    number = number.toUpperCase(); 
+  number = number.toUpperCase()
 
-    const result = convertRomanToArabic(number);
+  const result = convertRomanToArabic(number)
   if (result === 0) {
-        return errorHandling(next, generalError);
+    return errorHandling(next, generalError)
   }
 
-    return res.status(200).json({ result, resultHTML: `<p><span class="important">${number}</span> s'écrit <span class="important">${result}</span> en chiffres arabes.</p>` });
+  return res
+    .status(200)
+    .json({
+      result,
+      resultHTML: `<p><span class="important">${number}</span> s'écrit <span class="important">${result}</span> en chiffres arabes.</p>`
+    })
 }
 
 const convertArabicToRomanOutput = ({ res, next }, number) => {
-    
   // S'il n'y a pas les champs obligatoire
-    if (!(number)) {
+  if (!number) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Si ce n'est pas un nombre
-    number = parseInt(number);
+  number = parseInt(number)
   if (isNaN(number)) {
-        return errorHandling(next, { message: "Veuillez rentré un nombre valide.", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'Veuillez rentré un nombre valide.',
+      statusCode: 400
+    })
   }
 
-    const result = convertArabicToRoman(number);
+  const result = convertArabicToRoman(number)
-    return res.status(200).json({ result, resultHTML: `<p><span class="important">${formatNumberResult(number)}</span> s'écrit <span class="important">${result}</span> en chiffres romains.</p>` });
+  return res
+    .status(200)
+    .json({
+      result,
+      resultHTML: `<p><span class="important">${formatNumberResult(
+        number
+      )}</span> s'écrit <span class="important">${result}</span> en chiffres romains.</p>`
+    })
 }
 
-const convertRomanArabicObject = { convertRomanToArabicOutput, convertArabicToRomanOutput };
+const convertRomanArabicObject = {
+  convertRomanToArabicOutput,
+  convertArabicToRomanOutput
+}
 function executeFunction (option, value, { res, next }) {
-    return convertRomanArabicObject[option]({ res, next}, value);
+  return convertRomanArabicObject[option]({ res, next }, value)
 }
 
-module.exports = convertRomanArabicNumbersOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { value, functionName } = argsObject;
+  const { value, functionName } = argsObject
 
   // S'il n'y a pas les champs obligatoire
   if (!(value && functionName)) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Si la fonction n'existe pas
+  // eslint-disable-next-line
   if (!convertRomanArabicObject.hasOwnProperty(functionName)) {
-        return errorHandling(next, { message: "Cette conversion n'existe pas.", statusCode: 400 });
+    return errorHandling(next, {
+      message: "Cette conversion n'existe pas.",
+      statusCode: 400
+    })
   }
 
-    executeFunction(functionName, value, { res, next });
+  executeFunction(functionName, value, { res, next })
 }

api/assets/functions/main/convertTemperature.js

@@ -1,6 +1,6 @@
-const errorHandling                    = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields, generalError } = require('../../config/errors');
+const { requiredFields, generalError } = require('../../config/errors')
-const formatNumberResult               = require('../secondary/formatNumberResult');
+const formatNumberResult = require('../secondary/formatNumberResult')
 
 /**
  * @description Convertis des °C en °F et l'inverse aussi.
@@ -10,41 +10,44 @@ const formatNumberResult               = require('../secondary/formatNumberResul
  * @examples convertTemperature(23, '°F') → { result: 73.4, resultHTML: "73.4 °F" }
  */
 function convertTemperature (degree, unit) {
-    let temperatureValue = 0;
+  let temperatureValue = 0
-    if (unit === "°C") {
+  if (unit === '°C') {
-        temperatureValue = (degree - 32) * 5/9;
+    temperatureValue = ((degree - 32) * 5) / 9
-    }
+  } else if (unit === '°F') {
-    else if (unit === "°F") {
+    temperatureValue = (degree * 9) / 5 + 32
-        temperatureValue = ((degree * 9/5) + 32);
+  } else {
-    }
+    return false
-    else {
-        return false;
   }
   return {
     result: temperatureValue,
-        resultHTML: `<p>${formatNumberResult(degree)} ${(unit === '°C') ? "°F" : "°C"} = ${formatNumberResult(temperatureValue)} ${unit}</p>`
+    resultHTML: `<p>${formatNumberResult(degree)} ${
-    };
+      unit === '°C' ? '°F' : '°C'
+    } = ${formatNumberResult(temperatureValue)} ${unit}</p>`
+  }
 }
 
 /* OUTPUTS */
-module.exports = convertTemperatureOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { degree, unitToConvert } = argsObject;
+  let { degree, unitToConvert } = argsObject
 
   // S'il n'y a pas les champs obligatoire
   if (!(degree && unitToConvert)) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Si ce n'est pas un nombre
-    degree = parseFloat(degree);
+  degree = parseFloat(degree)
   if (isNaN(degree)) {
-        return errorHandling(next, { message: "Veuillez rentré un nombre valide.", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'Veuillez rentré un nombre valide.',
+      statusCode: 400
+    })
   }
 
-    const result = convertTemperature(degree, unitToConvert);
+  const result = convertTemperature(degree, unitToConvert)
   if (!result) {
-        return errorHandling(next, generalError);
+    return errorHandling(next, generalError)
   }
 
-    return res.status(200).json(result);
+  return res.status(200).json(result)
 }

api/assets/functions/main/fibonacci.js

@@ -1,6 +1,6 @@
-const errorHandling      = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields } = require('../../config/errors');
+const { requiredFields } = require('../../config/errors')
-const formatNumberResult = require('../secondary/formatNumberResult');
+const formatNumberResult = require('../secondary/formatNumberResult')
 
 /**
  * @description Calcule les counter premiers nombres de la suite de fibonacci.
@@ -8,39 +8,48 @@ const formatNumberResult = require('../secondary/formatNumberResult');
  */
 function fibonacci (counter, result = [], a = 0, b = 1) {
   if (counter === 0) {
-        return result; 
+    return result
   }
-    counter--;
+  counter--
-    result.push(a);
+  result.push(a)
-    return fibonacci(counter, result, b, a + b);
+  return fibonacci(counter, result, b, a + b)
 }
 
 /* OUTPUTS */
-module.exports = fibonacciOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { counter } = argsObject;
+  let { counter } = argsObject
 
   // S'il n'y a pas les champs obligatoire
-    if (!(counter)) {
+  if (!counter) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Si ce n'est pas un nombre
-    counter = parseInt(counter);
+  counter = parseInt(counter)
   if (isNaN(counter)) {
-        return errorHandling(next, { message: "Veuillez rentré un nombre valide.", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'Veuillez rentré un nombre valide.',
+      statusCode: 400
+    })
   }
 
   // Si le nombre dépasse LIMIT_COUNTER
-    const LIMIT_COUNTER = 51;
+  const LIMIT_COUNTER = 51
   if (counter >= LIMIT_COUNTER) {
-        return errorHandling(next, { message: `Par souci de performance, vous ne pouvez pas exécuter cette fonction avec un compteur dépassant ${LIMIT_COUNTER - 1}.`, statusCode: 400 });
+    return errorHandling(next, {
+      message: `Par souci de performance, vous ne pouvez pas exécuter cette fonction avec un compteur dépassant ${LIMIT_COUNTER -
+        1}.`,
+      statusCode: 400
+    })
   }
 
-    const result          = fibonacci(counter);
+  const result = fibonacci(counter)
-    const resultFormatted = result.map((number) => formatNumberResult(number));
+  const resultFormatted = result.map(number => formatNumberResult(number))
   return res.status(200).json({
     result,
     resultFormatted,
-        resultHTML: `<p>Les ${counter} premiers nombres de la suite de fibonacci :<br/> ${resultFormatted.join(', ')}</p>`
+    resultHTML: `<p>Les ${counter} premiers nombres de la suite de fibonacci :<br/> ${resultFormatted.join(
-    });
+      ', '
+    )}</p>`
+  })
 }

api/assets/functions/main/findLongestWord.js

@@ -1,5 +1,5 @@
-const errorHandling      = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields } = require('../../config/errors');
+const { requiredFields } = require('../../config/errors')
 
 /**
  * @description Renvoie le mot le plus long d'une chaîne de caractères
@@ -8,32 +8,32 @@ const { requiredFields } = require('../../config/errors');
  * @example findLongestWord('Chaîne de caractères') → 'caractères'
  */
 function findLongestWord (string) {
-    const arrayString = string.split(" ");
+  const arrayString = string.split(' ')
-    let stringLength = 0;
+  let stringLength = 0
-    let result = "";
+  let result = ''
 
-    arrayString.forEach((element) => {
+  arrayString.forEach(element => {
     if (element.length > stringLength) {
-            result = element;
+      result = element
-            stringLength = element.length;
+      stringLength = element.length
     }
-    });
+  })
 
-    return result;
+  return result
 }
 
 /* OUTPUTS */
-module.exports = findLongestWordOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    const { string } = argsObject;
+  const { string } = argsObject
 
   // S'il n'y a pas les champs obligatoire
-    if (!(string)) {
+  if (!string) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
-    const result = findLongestWord(string);
+  const result = findLongestWord(string)
   return res.status(200).json({
     result,
     resultHTML: `<p>Le mot le plus long est : <br/>"${result}"</p>`
-    });
+  })
 }

api/assets/functions/main/heapAlgorithm.js

@@ -1,6 +1,6 @@
-const errorHandling      = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields } = require('../../config/errors');
+const { requiredFields } = require('../../config/errors')
-const formatNumberResult = require('../secondary/formatNumberResult');
+const formatNumberResult = require('../secondary/formatNumberResult')
 
 /**
  * @description Retourne un tableau contenant toutes les possibilités d'anagramme d'un mot.
@@ -9,44 +9,56 @@ const formatNumberResult = require('../secondary/formatNumberResult');
  * @examples heapAlgorithm('abc') → ["abc", "acb", "bac", "bca", "cab", "cba"]
  */
 function heapAlgorithm (string) {
-    let results = [];
+  const results = []
 
   if (string.length === 1) {
-        results.push(string);
+    results.push(string)
-        return results;
+    return results
   }
 
   for (let indexString = 0; indexString < string.length; indexString++) {
-        const firstChar = string[indexString];
+    const firstChar = string[indexString]
-        const charsLeft = string.substring(0, indexString) + string.substring(indexString + 1);
+    const charsLeft =
-        const innerPermutations = heapAlgorithm(charsLeft);
+      string.substring(0, indexString) + string.substring(indexString + 1)
-        for (let indexPermutation = 0; indexPermutation < innerPermutations.length; indexPermutation++) {
+    const innerPermutations = heapAlgorithm(charsLeft)
-            results.push(firstChar + innerPermutations[indexPermutation]);
+    for (
+      let indexPermutation = 0;
+      indexPermutation < innerPermutations.length;
+      indexPermutation++
+    ) {
+      results.push(firstChar + innerPermutations[indexPermutation])
     }
   }
-    return results;
+  return results
 }
 
 /* OUTPUTS */
-module.exports = heapAlgorithmOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { string } = argsObject;
+  const { string } = argsObject
 
   // S'il n'y a pas les champs obligatoire
-    if (!(string)) {
+  if (!string) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Si la chaîne de caractère dépasse LIMIT_CHARACTERS caractères
-    const LIMIT_CHARACTERS = 7;
+  const LIMIT_CHARACTERS = 7
   if (string.length > LIMIT_CHARACTERS) {
-        return errorHandling(next, { message: `Par souci de performance, vous ne pouvez pas exécuter cette fonction avec un mot dépassant ${LIMIT_CHARACTERS} caractères.`, statusCode: 400 });
+    return errorHandling(next, {
+      message: `Par souci de performance, vous ne pouvez pas exécuter cette fonction avec un mot dépassant ${LIMIT_CHARACTERS} caractères.`,
+      statusCode: 400
+    })
   }
 
-    const result = heapAlgorithm(string);
+  const result = heapAlgorithm(string)
-    let resultHTML = `<p>Il y a ${formatNumberResult(result.length)} possibilités d'anagramme pour le mot "${string}" qui contient ${string.length} caractères, la liste : <br/><br/>`;
+  let resultHTML = `<p>Il y a ${formatNumberResult(
-    result.forEach((string) => {
+    result.length
-        resultHTML += string + "<br/>";
+  )} possibilités d'anagramme pour le mot "${string}" qui contient ${
-    });
+    string.length
-    resultHTML += "</p>";
+  } caractères, la liste : <br/><br/>`
-    return res.status(200).json({ result, resultHTML });
+  result.forEach(string => {
+    resultHTML += string + '<br/>'
+  })
+  resultHTML += '</p>'
+  return res.status(200).json({ result, resultHTML })
 }

api/assets/functions/main/isPalindrome.js

@@ -1,5 +1,5 @@
-const errorHandling      = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields } = require('../../config/errors');
+const { requiredFields } = require('../../config/errors')
 
 /**
  * @description Inverse la chaîne de caractère
@@ -8,7 +8,10 @@ const { requiredFields } = require('../../config/errors');
  * @example reverseString('Hello') → 'olleH'
  */
 function reverseString (string) {
-    return string.split("").reverse().join('');   
+  return string
+    .split('')
+    .reverse()
+    .join('')
 }
 
 /**
@@ -20,29 +23,36 @@ function reverseString(string) {
  * @example isPalindrome('kayak') → true
  */
 function isPalindrome (string, reverseStringResult) {
-    return string === reverseStringResult;
+  return string === reverseStringResult
 }
 
 /* OUTPUTS */
-module.exports = isPalindromeOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { string } = argsObject;
+  let { string } = argsObject
 
   // S'il n'y a pas les champs obligatoire
-    if (!(string)) {
+  if (!string) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   if (typeof string !== 'string') {
-        return errorHandling(next, { message: "Vous devez rentré une chaîne de caractère valide.", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'Vous devez rentré une chaîne de caractère valide.',
+      statusCode: 400
+    })
   }
 
-    string = string.toLowerCase();
+  string = string.toLowerCase()
 
-    const reverseStringResult = reverseString(string);
+  const reverseStringResult = reverseString(string)
-    const isPalindromeResult  = isPalindrome(string, reverseStringResult);
+  const isPalindromeResult = isPalindrome(string, reverseStringResult)
   return res.status(200).json({
     isPalindrome: isPalindromeResult,
     reverseString: reverseStringResult,
-        resultHTML: `<p>"${string}" ${(isPalindromeResult) ? "est" : "n'est pas"} un palindrome car <br/> "${string}" ${(isPalindromeResult) ? "===" : "!=="} "${reverseStringResult}"</p>`
+    resultHTML: `<p>"${string}" ${
-    });
+      isPalindromeResult ? 'est' : "n'est pas"
+    } un palindrome car <br/> "${string}" ${
+      isPalindromeResult ? '===' : '!=='
+    } "${reverseStringResult}"</p>`
+  })
 }

api/assets/functions/main/linkShortener.js

@@ -1,52 +0,0 @@
-const validator                       = require('validator');
-const errorHandling                   = require('../../utils/errorHandling');
-const { requiredFields, serverError } = require('../../config/errors');
-const Short_links                     = require('../../../models/short_links');
-
-module.exports = linkShortener = async ({ res, next }, argsObject) => {
-    let { url, shortcutName } = argsObject;
-
-    // S'il n'y a pas les champs obligatoire
-    if (!(url && shortcutName)) {
-        return errorHandling(next, requiredFields);
-    }
-
-    // Si ce n'est pas une url
-    if (!validator.isURL(url)) {
-        return errorHandling(next, { message: "Veuillez entré une URL valide.", statusCode: 400 });
-    }
-
-    // Si ce n'est pas de type slug
-    if (!validator.isSlug(shortcutName)) {
-        return errorHandling(next, { message: "Le nom de votre raccourci doit être de type slug (ne pas contenir d'espaces, ni de caractères spéciaux).", statusCode: 400 });
-    }
-
-    // Sanitize shortcutName
-    shortcutName = validator.escape(shortcutName);
-    shortcutName = validator.trim(shortcutName);
-    shortcutName = validator.blacklist(shortcutName, ' ');
-
-    try {
-        // Si l'url a déjà été raccourcie
-        const urlInDatabase = await Short_links.findOne({ where: { url } });
-        if (urlInDatabase) {
-            const urlShort = `https://short-links.divlo.fr/?q=${urlInDatabase.shortcut}`;
-            return errorHandling(next, { message: `L'url a déjà été raccourcie... <br/> <br/> <a target="_blank" rel="noopener noreferrer" href="${urlShort}">${urlShort}</a>`, statusCode: 400 });
-        }
-
-        // Si le nom du raccourci existe déjà
-        const shortcutInDatabase = await Short_links.findOne({ where: { shortcut: shortcutName } });
-        if (shortcutInDatabase) {
-            const urlShort = `https://short-links.divlo.fr/?q=${shortcutInDatabase.shortcut}`;
-            return errorHandling(next, { message: `Le nom du raccourci a déjà été utilisé... <br/> <br/> <a target="_blank" rel="noopener noreferrer" href="${urlShort}">${urlShort}</a>`, statusCode: 400 });
-        }
-
-        // Ajout du lien raccourci
-        const result             = await Short_links.create({ url, shortcut: shortcutName });
-        const shortcutLinkResult = `https://short-links.divlo.fr/?q=${result.shortcut}`;
-        return res.status(200).json({ resultHTML: `URL Raccourcie : <br/> <br/> <a target="_blank" rel="noopener noreferrer" href="${shortcutLinkResult}">${shortcutLinkResult}</a>`, result: shortcutLinkResult });
-    } catch {
-        console.log(error);
-        return errorHandling(next, serverError);
-    }
-}

api/assets/functions/main/randomNumber.js

@@ -1,6 +1,6 @@
-const errorHandling      = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields } = require('../../config/errors');
+const { requiredFields } = require('../../config/errors')
-const formatNumberResult = require('../secondary/formatNumberResult');
+const formatNumberResult = require('../secondary/formatNumberResult')
 
 /**
  * @description Génère un nombre aléatoire entre un minimum inclus et un maximum inclus.
@@ -10,28 +10,38 @@ const formatNumberResult = require('../secondary/formatNumberResult');
  * @examples randomNumber(1, 2) → retourne soit 1 ou 2
  */
 function randomNumber (min, max) {
-    return Math.floor(Math.random() * (max - min +1)) + min;
+  return Math.floor(Math.random() * (max - min + 1)) + min
 }
 
 /* OUTPUTS */
 const randomNumberOutput = ({ res, next }, argsObject) => {
-    let { min, max } = argsObject;
+  let { min, max } = argsObject
 
   // S'il n'y a pas les champs obligatoire
   if (!(min && max)) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
   // Si ce ne sont pas des nombres
-    min = parseInt(min);
+  min = parseInt(min)
-    max = parseInt(max);
+  max = parseInt(max)
   if (isNaN(min) || isNaN(max)) {
-        return errorHandling(next, { message: "Les paramètres min et max doivent être des nombres...", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'Les paramètres min et max doivent être des nombres...',
+      statusCode: 400
+    })
   }
 
-    const result = randomNumber(min, max);
+  const result = randomNumber(min, max)
-    return res.status(200).json({ result, resultHTML: `<p>Nombre aléatoire compris entre ${min} inclus et ${max} inclus : <strong>${formatNumberResult(result)}</strong></p>` });
+  return res
+    .status(200)
+    .json({
+      result,
+      resultHTML: `<p>Nombre aléatoire compris entre ${min} inclus et ${max} inclus : <strong>${formatNumberResult(
+        result
+      )}</strong></p>`
+    })
 }
 
-exports.randomNumber       = randomNumber;
+exports.randomNumber = randomNumber
-exports.randomNumberOutput = randomNumberOutput;
+exports.randomNumberOutput = randomNumberOutput

api/assets/functions/main/randomQuote.js

@@ -1,26 +1,24 @@
-const errorHandling   = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { serverError } = require('../../config/errors');
+const { serverError } = require('../../config/errors')
-const Quotes          = require('../../../models/quotes');
+const Quotes = require('../../../models/quotes')
-const Users           = require('../../../models/users');
+const Users = require('../../../models/users')
-const sequelize       = require('../../utils/database');
+const sequelize = require('../../utils/database')
 
-module.exports = randomQuote = async ({ res, next }, _argsObject) => {
+module.exports = async ({ res, next }, _argsObject) => {
   try {
     const quote = await Quotes.findOne({
       order: sequelize.random(),
-            include: [
+      include: [{ model: Users, attributes: ['name', 'logo'] }],
-                { model: Users, attributes: ["name", "logo"] }
-            ],
       attributes: {
-                exclude: ["isValidated"]
+        exclude: ['isValidated']
       },
       where: {
-                isValidated: 1,
+        isValidated: 1
       }
-        });
+    })
-        return res.status(200).json(quote);
+    return res.status(200).json(quote)
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }

api/assets/functions/main/rightPrice.js

@@ -1,57 +1,60 @@
-const { randomNumber }    = require('./randomNumber');
+const { randomNumber } = require('./randomNumber')
-const errorHandling       = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { serverError }     = require('../../config/errors');
+const { serverError } = require('../../config/errors')
-const { SCRAPER_API_KEY } = require('../../config/config');
+const { SCRAPER_API_KEY } = require('../../config/config')
-const axios               = require('axios');
+const axios = require('axios')
-const { JSDOM }           = require("jsdom");
+const { JSDOM } = require('jsdom')
 
 const subjectList = [
-    "smartphone",
+  'smartphone',
-    "pc+gamer",
+  'pc+gamer',
-    "pc+portable",
+  'pc+portable',
-    "TV",
+  'TV',
-    "casque",
+  'casque',
-    "clavier",
+  'clavier',
-    "souris",
+  'souris',
-    "ecran",
+  'ecran',
-    "jeux+vidéos"
+  'jeux+vidéos'
-];
+]
 
 function getRandomArrayElement (array) {
-    return array[randomNumber(0, array.length - 1)];
+  return array[randomNumber(0, array.length - 1)]
 }
 
 async function getAmazonProductList (subject) {
-    const url               = `https://www.amazon.fr/s?k=${subject}`;
+  const url = `https://www.amazon.fr/s?k=${subject}`
-    const { data }          = await axios.get(`http://api.scraperapi.com/?api_key=${SCRAPER_API_KEY}&url=${url}`);
+  const { data } = await axios.get(
-    const { document }      = (new JSDOM(data)).window;
+    `http://api.scraperapi.com/?api_key=${SCRAPER_API_KEY}&url=${url}`
-    const amazonProductList = document.querySelectorAll('.s-result-item');
+  )
-    const productsList      = [];
+  const { document } = new JSDOM(data).window
-    for (let indexProduct in amazonProductList) {
+  const amazonProductList = document.querySelectorAll('.s-result-item')
+  const productsList = []
+  for (const indexProduct in amazonProductList) {
     try {
-            const elementProduct = amazonProductList[indexProduct];
+      const elementProduct = amazonProductList[indexProduct]
-            const productImage   = elementProduct.querySelector('.s-image');
+      const productImage = elementProduct.querySelector('.s-image')
-            const originalPrice  = elementProduct.querySelector(".a-price-whole").innerHTML;
+      const originalPrice = elementProduct.querySelector('.a-price-whole')
+        .innerHTML
       productsList.push({
-                name: productImage["alt"],
+        name: productImage.alt,
-                image: productImage["src"],
+        image: productImage.src,
-                price: Number(originalPrice.replace(",", ".").replace(" ", ""))
+        price: Number(originalPrice.replace(',', '.').replace(' ', ''))
-            });
+      })
     } catch (_error) {
-            continue;
+      continue
     }
   }
-    return productsList;
+  return productsList
 }
 
-module.exports = rightPriceOutput = async ({ res, next }, _argsObject) => {
+module.exports = async ({ res, next }, _argsObject) => {
-    const subject = getRandomArrayElement(subjectList);
+  const subject = getRandomArrayElement(subjectList)
   try {
-        const productsList  = await getAmazonProductList(subject);
+    const productsList = await getAmazonProductList(subject)
-        const randomProduct = getRandomArrayElement(productsList);
+    const randomProduct = getRandomArrayElement(productsList)
-        return res.status(200).json({ subject, ...randomProduct });
+    return res.status(200).json({ subject, ...randomProduct })
   } catch (error) {
-        console.error(error);
+    console.error(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }

api/assets/functions/main/sortArray.js

@@ -1,56 +1,69 @@
-const errorHandling      = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields } = require('../../config/errors');
+const { requiredFields } = require('../../config/errors')
-const formatNumberResult = require('../secondary/formatNumberResult');
+const formatNumberResult = require('../secondary/formatNumberResult')
 
 function minNumber (array) {
   let minNumber = { index: 0, value: array[0] }
   for (let index = 1; index < array.length; index++) {
-        const number = array[index];
+    const number = array[index]
     if (number < minNumber.value) {
       minNumber = { index: index, value: array[index] }
     }
   }
-    return minNumber;
+  return minNumber
 }
 
 function sortArray (array) {
-    const arrayDuplicated = [...array];
+  const arrayDuplicated = [...array]
-    const resultArray = [];
+  const resultArray = []
   while (array.length !== resultArray.length) {
-        const min = minNumber(arrayDuplicated);
+    const min = minNumber(arrayDuplicated)
-        resultArray.push(min.value);
+    resultArray.push(min.value)
-        arrayDuplicated.splice(min.index, 1);
+    arrayDuplicated.splice(min.index, 1)
   }
-    return resultArray;
+  return resultArray
 }
 
 /* OUTPUTS */
-module.exports = sortArrayOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { numbersList } = argsObject;
+  const { numbersList } = argsObject
 
   // S'il n'y a pas les champs obligatoire
-    if (!(numbersList)) {
+  if (!numbersList) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
-    const numbersListArray = numbersList.split(',').map((number) => number.trim().replace(' ', '')).map(Number);
+  const numbersListArray = numbersList
+    .split(',')
+    .map(number => number.trim().replace(' ', ''))
+    .map(Number)
 
   // Si ce n'est pas une liste de nombres
   if (numbersListArray.includes(NaN)) {
-        return errorHandling(next, { message: "Vous devez rentrer une liste de nombres séparée par des virgules valide.", statusCode: 400 });
+    return errorHandling(next, {
+      message:
+        'Vous devez rentrer une liste de nombres séparée par des virgules valide.',
+      statusCode: 400
+    })
   }
 
   // Si la taille du tableau dépasse LIMIT_ARRAY_LENGTH
-    const LIMIT_ARRAY_LENGTH = 31;
+  const LIMIT_ARRAY_LENGTH = 31
   if (numbersListArray.length >= LIMIT_ARRAY_LENGTH) {
-        return errorHandling(next, { message: `Par souci de performance, vous ne pouvez pas exécuter cette fonction avec une liste de nombres dépassant ${LIMIT_ARRAY_LENGTH - 1} nombres.`, statusCode: 400 });
+    return errorHandling(next, {
+      message: `Par souci de performance, vous ne pouvez pas exécuter cette fonction avec une liste de nombres dépassant ${LIMIT_ARRAY_LENGTH -
+        1} nombres.`,
+      statusCode: 400
+    })
   }
 
-    const result          = sortArray(numbersListArray);
+  const result = sortArray(numbersListArray)
-    const resultFormatted = result.map((number) => formatNumberResult(number));
+  const resultFormatted = result.map(number => formatNumberResult(number))
   return res.status(200).json({
     result,
     resultFormatted,
-        resultHTML: `<p>La liste de nombres dans l'ordre croissant :<br/> ${resultFormatted.join(', ')}</p>`
+    resultHTML: `<p>La liste de nombres dans l'ordre croissant :<br/> ${resultFormatted.join(
-    });
+      ', '
+    )}</p>`
+  })
 }

api/assets/functions/main/weatherRequest.js

@@ -1,10 +1,10 @@
-const axios               = require('axios');
+const axios = require('axios')
-const Queue               = require('smart-request-balancer');
+const Queue = require('smart-request-balancer')
-const errorHandling       = require('../../utils/errorHandling');
+const errorHandling = require('../../utils/errorHandling')
-const { requiredFields }  = require('../../config/errors');
+const { requiredFields } = require('../../config/errors')
-const { WEATHER_API_KEY } = require('../../config/config');
+const { WEATHER_API_KEY } = require('../../config/config')
-const dateTimeUTC         = require('../secondary/dateTimeManagement');
+const dateTimeUTC = require('../secondary/dateTimeManagement')
-const capitalize          = require('../secondary/capitalize');
+const capitalize = require('../secondary/capitalize')
 
 const queue = new Queue({
   /*
@@ -17,30 +17,57 @@ const queue = new Queue({
       rate: 50,
       limit: 60,
       priority: 1
-        },
     }
-});
+  }
+})
 
 /* OUTPUTS */
-module.exports = weatherRequestOutput = ({ res, next }, argsObject) => {
+module.exports = ({ res, next }, argsObject) => {
-    let { cityName } = argsObject;
+  let { cityName } = argsObject
 
   // S'il n'y a pas les champs obligatoire
-    if (!(cityName)) {
+  if (!cityName) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
 
-    cityName = cityName.split(' ').join('+');
+  cityName = cityName.split(' ').join('+')
 
   // Récupère les données météo grâce à l'API : openweathermap.org. (→ avec limite de 50 requêtes par minute)
-    queue.request(() => {
+  queue.request(
-        axios.get(`https://api.openweathermap.org/data/2.5/weather?q=${cityName}&lang=fr&units=metric&appid=${WEATHER_API_KEY}`)
+    () => {
-            .then((response) =>{
+      axios
-                const json = response.data;
+        .get(
-                const showDateTimeValue = dateTimeUTC((json.timezone / 60 / 60).toString()).showDateTimeValue;
+          `https://api.openweathermap.org/data/2.5/weather?q=${cityName}&lang=fr&units=metric&appid=${WEATHER_API_KEY}`
-                const resultHTML = `<p>🌎 Position : <a href="https://www.google.com/maps/search/?api=1&query=${json.coord.lat},${json.coord.lon}" rel="noopener noreferrer" target="_blank">${json.name}, ${json.sys.country}</a><br/>⏰ Date et heure : ${showDateTimeValue} <br/>☁️ Météo : ${capitalize(json.weather[0].description)}<br/>🌡️ Température : ${json.main.temp} °C<br/> 💧 Humidité : ${json.main.humidity}% <br/> <img src="https://openweathermap.org/img/wn/${json.weather[0].icon}@2x.png"/></p>`;
+        )
-                return res.status(200).json({ result: json, resultHTML });
+        .then(response => {
+          const json = response.data
+          const showDateTimeValue = dateTimeUTC(
+            (json.timezone / 60 / 60).toString()
+          ).showDateTimeValue
+          const resultHTML = `<p>🌎 Position : <a href="https://www.google.com/maps/search/?api=1&query=${
+            json.coord.lat
+          },${json.coord.lon}" rel="noopener noreferrer" target="_blank">${
+            json.name
+          }, ${
+            json.sys.country
+          }</a><br/>⏰ Date et heure : ${showDateTimeValue} <br/>☁️ Météo : ${capitalize(
+            json.weather[0].description
+          )}<br/>🌡️ Température : ${json.main.temp} °C<br/> 💧 Humidité : ${
+            json.main.humidity
+          }% <br/> <img src="https://openweathermap.org/img/wn/${
+            json.weather[0].icon
+          }@2x.png"/></p>`
+          return res.status(200).json({ result: json, resultHTML })
         })
-            .catch(() => errorHandling(next, { message: "La ville n'existe pas (dans l'API de openweathermap.org).", statusCode: 404 }));
+        .catch(() =>
-    }, 'everyone', 'weatherRequest');
+          errorHandling(next, {
+            message:
+              "La ville n'existe pas (dans l'API de openweathermap.org).",
+            statusCode: 404
+          })
+        )
+    },
+    'everyone',
+    'weatherRequest'
+  )
 }

api/assets/functions/secondary/capitalize.js

@@ -9,4 +9,4 @@ function capitalize(s) {
   return s.charAt(0).toUpperCase() + s.slice(1)
 }
 
-module.exports = capitalize;
+module.exports = capitalize

api/assets/functions/secondary/dateTimeManagement.js

@@ -5,12 +5,12 @@
  * @examples dateTimeUTC('0')
  */
 function dateTimeUTC (utc) {
-    const timeNow = new Date();
+  const timeNow = new Date()
-    const utcOffset = timeNow.getTimezoneOffset();
+  const utcOffset = timeNow.getTimezoneOffset()
-    timeNow.setMinutes(timeNow.getMinutes() + utcOffset);
+  timeNow.setMinutes(timeNow.getMinutes() + utcOffset)
-    const enteredOffset = parseFloat(utc)*60;
+  const enteredOffset = parseFloat(utc) * 60
-    timeNow.setMinutes(timeNow.getMinutes() + enteredOffset);
+  timeNow.setMinutes(timeNow.getMinutes() + enteredOffset)
-    return showDateTime(timeNow);
+  return showDateTime(timeNow)
 }
 
 /**
@@ -21,13 +21,14 @@ function dateTimeUTC(utc) {
  * @examples dateTimeUTC('0') → dateTimeUTC vous renvoie l'exécution de showDateTime
  */
 function showDateTime (timeNow) {
-    const year    = timeNow.getFullYear();
+  const year = timeNow.getFullYear()
-    const month   = ('0'+(timeNow.getMonth()+1)).slice(-2);
+  const month = ('0' + (timeNow.getMonth() + 1)).slice(-2)
-    const day     = ('0'+timeNow.getDate()).slice(-2);
+  const day = ('0' + timeNow.getDate()).slice(-2)
-    const hour    = ('0'+timeNow.getHours()).slice(-2);
+  const hour = ('0' + timeNow.getHours()).slice(-2)
-    const minute  = ('0'+timeNow.getMinutes()).slice(-2);
+  const minute = ('0' + timeNow.getMinutes()).slice(-2)
-    const second  = ('0'+timeNow.getSeconds()).slice(-2);
+  const second = ('0' + timeNow.getSeconds()).slice(-2)
-    const showDateTimeValue = day + "/" + month + "/" + year + " - " + hour + ":" + minute + ":" + second;
+  const showDateTimeValue =
+    day + '/' + month + '/' + year + ' - ' + hour + ':' + minute + ':' + second
   const objectDateTime = {
     year: year,
     month: month,
@@ -36,8 +37,8 @@ function showDateTime(timeNow) {
     minute: minute,
     second: second,
     showDateTimeValue: showDateTimeValue
-    };
+  }
-    return objectDateTime;
+  return objectDateTime
 }
 
-module.exports = dateTimeUTC;
+module.exports = dateTimeUTC

api/assets/functions/secondary/formatNumberResult.js

@@ -5,10 +5,10 @@
  * @returns {String} - Le nombre formaté
  * @examples formatNumberResult(76120) → '76 120'
  */
-function formatNumberResult(number, separator = ".") {
+function formatNumberResult (number, separator = '.') {
-    let parts = number.toString().split(separator);
+  const parts = number.toString().split(separator)
-    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, " ");
+  parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ' ')
-    return parts.join(separator);
+  return parts.join(separator)
 }
 
-module.exports = formatNumberResult;
+module.exports = formatNumberResult

api/assets/utils/database.js

@@ -1,9 +1,14 @@
-const Sequelize    = require('sequelize');
+const Sequelize = require('sequelize')
-const { DATABASE } = require('../config/config');
+const { DATABASE } = require('../config/config')
 
-const sequelize = new Sequelize(DATABASE.name, DATABASE.user, DATABASE.password, {
+const sequelize = new Sequelize(
+  DATABASE.name,
+  DATABASE.user,
+  DATABASE.password,
+  {
     dialect: 'mysql',
     host: DATABASE.host
-});
+  }
+)
 
-module.exports = sequelize;
+module.exports = sequelize

api/assets/utils/deleteFilesNameStartWith.js

@@ -1,19 +1,19 @@
-const fs   = require("fs");
+const fs = require('fs')
-const path = require("path");
+const path = require('path')
 
 function deleteFilesNameStartWith (pattern, dirPath, callback) {
   fs.readdir(path.resolve(dirPath), (_error, fileNames) => {
     for (const name of fileNames) {
-            const splitedName = name.split('.');
+      const splitedName = name.split('.')
       if (splitedName.length === 2) {
-                const fileName = splitedName[0];
+        const fileName = splitedName[0]
         if (fileName === pattern && name !== 'default.png') {
-                    return fs.unlink(path.join(dirPath, name), callback);
+          return fs.unlink(path.join(dirPath, name), callback)
         }
       }
     }
-        return callback();
+    return callback()
-    });
+  })
 }
 
-module.exports = deleteFilesNameStartWith;
+module.exports = deleteFilesNameStartWith

api/assets/utils/errorHandling.js

@@ -1,7 +1,7 @@
 function errorHandling (next, { statusCode, message }) {
-    const error = new Error(message);
+  const error = new Error(message)
-    error.statusCode = statusCode;
+  error.statusCode = statusCode
-    next(error);
+  next(error)
 }
 
-module.exports = errorHandling;
+module.exports = errorHandling

api/assets/utils/getPagesHelper.js

@@ -1,10 +1,10 @@
-const errorHandling     = require('../utils/errorHandling');
+const errorHandling = require('../utils/errorHandling')
-const { serverError }   = require('../config/errors');
+const { serverError } = require('../config/errors')
-const helperQueryNumber = require('../utils/helperQueryNumber');
+const helperQueryNumber = require('../utils/helperQueryNumber')
 
 const DEFAULT_OPTIONS = {
   order: [['createdAt', 'DESC']]
-};
+}
 
 /**
  * @description Permet de faire un système de pagination sur un model Sequelize
@@ -12,23 +12,27 @@ const DEFAULT_OPTIONS = {
  * @param {*} Model Model Sequelize
  * @param {Object} options Options avec clause where etc.
  */
-async function getPagesHelper({ req, res, next }, Model, options = DEFAULT_OPTIONS) {
+async function getPagesHelper (
-    const page   = helperQueryNumber(req.query.page, 1);
+  { req, res, next },
-    const limit  = helperQueryNumber(req.query.limit, 10);
+  Model,
-    const offset = (page - 1) * limit;
+  options = DEFAULT_OPTIONS
+) {
+  const page = helperQueryNumber(req.query.page, 1)
+  const limit = helperQueryNumber(req.query.limit, 10)
+  const offset = (page - 1) * limit
   try {
     const result = await Model.findAndCountAll({
       limit,
       offset,
       ...options
-        });
+    })
-        const { count, rows } = result;
+    const { count, rows } = result
-        const hasMore         = (page * limit) < count;
+    const hasMore = page * limit < count
-        return res.status(200).json({ totalItems: count, hasMore, rows });
+    return res.status(200).json({ totalItems: count, hasMore, rows })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
-module.exports = getPagesHelper;
+module.exports = getPagesHelper

api/assets/utils/helperQueryNumber.js

@@ -1,6 +1,6 @@
 function helperQueryNumber (value, defaultValue) {
-    if (value && !isNaN(value)) return parseInt(value);
+  if (value && !isNaN(value)) return parseInt(value)
-    return defaultValue;
+  return defaultValue
 }
 
-module.exports = helperQueryNumber;
+module.exports = helperQueryNumber

api/controllers/admin.js

@@ -1,320 +1,424 @@
-const path                           = require('path');
+const path = require('path')
-const fs                             = require('fs');
+const fs = require('fs')
-const { validationResult }           = require('express-validator');
+const { validationResult } = require('express-validator')
-const errorHandling                  = require('../assets/utils/errorHandling');
+const errorHandling = require('../assets/utils/errorHandling')
-const { serverError }                = require('../assets/config/errors');
+const { serverError } = require('../assets/config/errors')
-const Functions                      = require('../models/functions');
+const Functions = require('../models/functions')
-const Categories                     = require('../models/categories');
+const Categories = require('../models/categories')
-const Quotes                         = require('../models/quotes');
+const Quotes = require('../models/quotes')
-const Users                          = require('../models/users');
+const Users = require('../models/users')
-const helperQueryNumber              = require('../assets/utils/helperQueryNumber');
+const helperQueryNumber = require('../assets/utils/helperQueryNumber')
-const getPagesHelper                 = require('../assets/utils/getPagesHelper');
+const getPagesHelper = require('../assets/utils/getPagesHelper')
-const Sequelize                      = require('sequelize');
+const Sequelize = require('sequelize')
-const deleteFilesNameStartWith       = require('../assets/utils/deleteFilesNameStartWith');
+const deleteFilesNameStartWith = require('../assets/utils/deleteFilesNameStartWith')
-const { EMAIL_INFO, FRONT_END_HOST } = require('../assets/config/config');
+const { EMAIL_INFO, FRONT_END_HOST } = require('../assets/config/config')
-const transporter                    = require('../assets/config/transporter');
+const transporter = require('../assets/config/transporter')
-const { emailQuoteTemplate }         = require('../assets/config/emails');
+const { emailQuoteTemplate } = require('../assets/config/emails')
 
-const handleEditFunction = async (res, resultFunction, { title, slug, description, type, categorieId, isOnline }, imageName = false) => {
+const handleEditFunction = async (
-    resultFunction.title       = title;
+  res,
-    resultFunction.slug        = slug;
+  resultFunction,
-    resultFunction.description = description;
+  { title, slug, description, type, categorieId, isOnline },
-    resultFunction.type        = type;
+  imageName = false
-    resultFunction.categorieId = categorieId;
+) => {
-    resultFunction.isOnline    = isOnline;
+  resultFunction.title = title
+  resultFunction.slug = slug
+  resultFunction.description = description
+  resultFunction.type = type
+  resultFunction.categorieId = categorieId
+  resultFunction.isOnline = isOnline
   if (imageName) {
-        resultFunction.image = `/images/functions/${imageName}`;
+    resultFunction.image = `/images/functions/${imageName}`
   }
-    const result = await resultFunction.save();
+  const result = await resultFunction.save()
-    res.status(200).json({ message: "La fonction a bien été modifié!", result });
+  res.status(200).json({ message: 'La fonction a bien été modifié!', result })
 }
 
 exports.getFunctions = async (req, res, next) => {
-    const categoryId = helperQueryNumber(req.query.categoryId, 0);
+  const categoryId = helperQueryNumber(req.query.categoryId, 0)
-    let   search     = req.query.search;
+  let search = req.query.search
-    try { search = search.toLowerCase(); } catch {};
+  try {
+    search = search.toLowerCase()
+  } catch {}
   const options = {
     where: {
       // Trie par catégorie
-            ... (categoryId !== 0) && { categorieId: categoryId },
+      ...(categoryId !== 0 && { categorieId: categoryId }),
       // Recherche
-            ... (search != undefined) && { 
+      ...(search != null && {
         [Sequelize.Op.or]: [
-                    { title: Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('title')), 'LIKE', `%${search}%`) },
+          {
-                    { slug: Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('slug')), 'LIKE', `%${search}%`) },
+            title: Sequelize.where(
-                    { description: Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('description')), 'LIKE', `%${search}%`) }
+              Sequelize.fn('LOWER', Sequelize.col('title')),
-                ]
+              'LIKE',
-            }
+              `%${search}%`
+            )
           },
-        include: [
+          {
-            { model: Categories, attributes: ["name", "color"] }
+            slug: Sequelize.where(
-        ],
+              Sequelize.fn('LOWER', Sequelize.col('slug')),
+              'LIKE',
+              `%${search}%`
+            )
+          },
+          {
+            description: Sequelize.where(
+              Sequelize.fn('LOWER', Sequelize.col('description')),
+              'LIKE',
+              `%${search}%`
+            )
+          }
+        ]
+      })
+    },
+    include: [{ model: Categories, attributes: ['name', 'color'] }],
     attributes: {
-            exclude: ["updatedAt", "utilizationForm", "article", "isOnline"]
+      exclude: ['updatedAt', 'utilizationForm', 'article', 'isOnline']
     },
     order: [['createdAt', 'DESC']]
-    };
+  }
-    return await getPagesHelper({ req, res, next }, Functions, options);
+  return await getPagesHelper({ req, res, next }, Functions, options)
 }
 
 exports.getFunctionBySlug = (req, res, next) => {
-    const { slug } = req.params;
+  const { slug } = req.params
   Functions.findOne({
     where: { slug },
-        include: [
+    include: [{ model: Categories, attributes: ['name', 'color'] }]
-            { model: Categories, attributes: ["name", "color"] }
-        ]
   })
-        .then((result) => {
+    .then(result => {
       if (!result) {
-                return errorHandling(next, { message: "La fonction n'existe pas.", statusCode: 404 });
+        return errorHandling(next, {
-            }
+          message: "La fonction n'existe pas.",
-            try { result.utilizationForm = JSON.parse(result.utilizationForm); } catch {}
+          statusCode: 404
-            return res.status(200).json(result);
+        })
+      }
+      try {
+        result.utilizationForm = JSON.parse(result.utilizationForm)
+      } catch {}
+      return res.status(200).json(result)
+    })
+    .catch(error => {
+      console.log(error)
+      return errorHandling(next, serverError)
     })
-        .catch((error) => {
-            console.log(error);
-            return errorHandling(next, serverError);
-        });
 }
 
 exports.postFunction = (req, res, next) => {
-    const { title, slug, description, type, categorieId } = req.body;
+  const { title, slug, description, type, categorieId } = req.body
-    const image = req.files.image;
+  const image = req.files.image
-    const errors = validationResult(req);
+  const errors = validationResult(req)
   if (!errors.isEmpty()) {
-        return errorHandling(next, { message: errors.array()[0].msg, statusCode: 400 });
+    return errorHandling(next, {
+      message: errors.array()[0].msg,
+      statusCode: 400
+    })
   }
-    if (!image || image.truncated && (
+  if (
-        image.mimetype !== 'image/png' || 
+    (!image || image.truncated) &&
+    (image.mimetype !== 'image/png' ||
       image.mimetype !== 'image/jpg' ||
-        image.mimetype !== 'image/jpeg'
+      image.mimetype !== 'image/jpeg')
-    )) {
+  ) {
-        return errorHandling(next, { message:"La fonction doit avoir une image valide.", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'La fonction doit avoir une image valide.',
+      statusCode: 400
+    })
   }
-    const splitedImageName = image.name.split('.');
+  const splitedImageName = image.name.split('.')
-    if (splitedImageName.length !== 2) return errorHandling(next, serverError);
+  if (splitedImageName.length !== 2) return errorHandling(next, serverError)
-    const imageName = slug + '.' + splitedImageName[1];
+  const imageName = slug + '.' + splitedImageName[1]
-    image.mv(path.join(__dirname, '..', 'assets', 'images', 'functions') + '/' + imageName, async (error) => {
+  image.mv(
-        if (error) return errorHandling(next, serverError);
+    path.join(__dirname, '..', 'assets', 'images', 'functions') +
+      '/' +
+      imageName,
+    async error => {
+      if (error) return errorHandling(next, serverError)
       try {
-            const result = await Functions.create({ title, slug, description, type, categorieId, image: `/images/functions/${imageName}` });
+        const result = await Functions.create({
-            return res.status(201).json({ message: "La fonction a été correctement ajouté!", result });
+          title,
+          slug,
+          description,
+          type,
+          categorieId,
+          image: `/images/functions/${imageName}`
+        })
+        return res
+          .status(201)
+          .json({ message: 'La fonction a été correctement ajouté!', result })
       } catch (error) {
-            console.log(error);
+        console.log(error)
-            return errorHandling(next, serverError);
+        return errorHandling(next, serverError)
       }
-    });
+    }
+  )
 }
 
 exports.putFunction = async (req, res, next) => {
-    const { id }                                                    = req.params;
+  const { id } = req.params
-    const { title, slug, description, type, categorieId, isOnline } = req.body;
+  const { title, slug, description, type, categorieId, isOnline } = req.body
-    const image                                                     = req.files.image;
+  const image = req.files.image
-    const errors = validationResult(req);
+  const errors = validationResult(req)
   if (!errors.isEmpty()) {
-        return errorHandling(next, { message: errors.array()[0].msg, statusCode: 400 });
+    return errorHandling(next, {
+      message: errors.array()[0].msg,
+      statusCode: 400
+    })
   }
   try {
     // Vérifie si la fonction existe
-        const resultFunction = await Functions.findOne({ where: { id } });
+    const resultFunction = await Functions.findOne({ where: { id } })
     if (!resultFunction) {
-            return errorHandling(next, { message: "La fonction n'existe pas.", statusCode: 404 });
+      return errorHandling(next, {
+        message: "La fonction n'existe pas.",
+        statusCode: 404
+      })
     }
 
     // Vérifie si le slug existe déjà
-        const FunctionSlug = await Functions.findOne({ where: { slug } });
+    const FunctionSlug = await Functions.findOne({ where: { slug } })
-        if (!FunctionSlug && FunctionSlug.id != resultFunction.id) {
+    if (!FunctionSlug && FunctionSlug.id !== resultFunction.id) {
-            return errorHandling(next, { message: "Le slug existe déjà...", statusCode: 404 });
+      return errorHandling(next, {
+        message: 'Le slug existe déjà...',
+        statusCode: 404
+      })
     }
 
     // Sauvegarde de la fonction
-        if (image != undefined) {
+    if (image != null) {
-            if (image.truncated && (
+      if (
-                image.mimetype !== 'image/png' || 
+        image.truncated &&
+        (image.mimetype !== 'image/png' ||
           image.mimetype !== 'image/jpg' ||
-                image.mimetype !== 'image/jpeg'
+          image.mimetype !== 'image/jpeg')
-            )) {
+      ) {
-                return errorHandling(next, { message:"La fonction doit avoir une image valide.", statusCode: 400 });
+        return errorHandling(next, {
+          message: 'La fonction doit avoir une image valide.',
+          statusCode: 400
+        })
       }
-            const splitedImageName = image.name.split('.');
+      const splitedImageName = image.name.split('.')
-            if (splitedImageName.length !== 2) return errorHandling(next, serverError);
+      if (splitedImageName.length !== 2) return errorHandling(next, serverError)
-            const imageName = slug + '.' + splitedImageName[1];
+      const imageName = slug + '.' + splitedImageName[1]
       // Supprime les anciennes images
-            const functionPath = path.join(__dirname, '..', 'assets', 'images', 'functions');
+      const functionPath = path.join(
+        __dirname,
+        '..',
+        'assets',
+        'images',
+        'functions'
+      )
       deleteFilesNameStartWith(slug, functionPath, () => {
-                image.mv(path.join(functionPath, imageName), async (error) => {
+        image.mv(path.join(functionPath, imageName), async error => {
-                    if (error) return errorHandling(next, serverError);
+          if (error) return errorHandling(next, serverError)
-                    return await handleEditFunction(res, resultFunction, { title, slug, description, type, categorieId, isOnline }, imageName);
+          return await handleEditFunction(
-                });
+            res,
-            });
+            resultFunction,
+            { title, slug, description, type, categorieId, isOnline },
+            imageName
+          )
+        })
+      })
     } else {
-            return await handleEditFunction(res, resultFunction, { title, slug, description, type, categorieId, isOnline });
+      return await handleEditFunction(res, resultFunction, {
+        title,
+        slug,
+        description,
+        type,
+        categorieId,
+        isOnline
+      })
     }
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.putFunctionArticle = async (req, res, next) => {
-    const { id }      = req.params;
+  const { id } = req.params
-    const { article } = req.body;
+  const { article } = req.body
 
   try {
     // Vérifie si la fonction existe
-        const resultFunction = await Functions.findOne({ where: { id } });
+    const resultFunction = await Functions.findOne({ where: { id } })
     if (!resultFunction) {
-            return errorHandling(next, { message: "La fonction n'existe pas.", statusCode: 404 });
+      return errorHandling(next, {
+        message: "La fonction n'existe pas.",
+        statusCode: 404
+      })
     }
-        resultFunction.article = article;
+    resultFunction.article = article
-        const result = await resultFunction.save();
+    const result = await resultFunction.save()
-        return res.status(200).json(result);
+    return res.status(200).json(result)
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.putFunctionForm = async (req, res, next) => {
-    const { id }   = req.params;
+  const { id } = req.params
-    const { form } = req.body;
+  const { form } = req.body
 
   try {
     // Vérifie si la fonction existe
-        const resultFunction = await Functions.findOne({ where: { id } });
+    const resultFunction = await Functions.findOne({ where: { id } })
     if (!resultFunction) {
-            return errorHandling(next, { message: "La fonction n'existe pas.", statusCode: 404 });
+      return errorHandling(next, {
+        message: "La fonction n'existe pas.",
+        statusCode: 404
+      })
     }
-        resultFunction.utilizationForm = JSON.stringify(form);
+    resultFunction.utilizationForm = JSON.stringify(form)
-        const result = await resultFunction.save();
+    const result = await resultFunction.save()
-        return res.status(200).json(result);
+    return res.status(200).json(result)
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.deleteFunction = async (req, res, next) => {
-    const { id } = req.params;
+  const { id } = req.params
   try {
-        const result = await Functions.findOne({ where: { id } });
+    const result = await Functions.findOne({ where: { id } })
     if (!result) {
-            return errorHandling(next, { message: "La fonction n'existe pas.", statusCode: 404 });
+      return errorHandling(next, {
+        message: "La fonction n'existe pas.",
+        statusCode: 404
+      })
     }
-        if (result.image !== "/images/functions/default.png") {
+    if (result.image !== '/images/functions/default.png') {
-            const filePath = path.join(__dirname, '..', 'assets', result.image);
+      const filePath = path.join(__dirname, '..', 'assets', result.image)
-            fs.unlinkSync(filePath); // supprime le fichier
+      fs.unlinkSync(filePath) // supprime le fichier
     }
-        await result.destroy();
+    await result.destroy()
-        res.status(200).json({ message: "La fonction a été correctement supprimé!"});
+    res
+      .status(200)
+      .json({ message: 'La fonction a été correctement supprimé!' })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.postCategory = async (req, res, next) => {
-    const { name, color } = req.body;
+  const { name, color } = req.body
   if (!(name && color)) {
-        return errorHandling(next, { message: "La catégorie doit avoir un nom et une couleur." });
+    return errorHandling(next, {
+      message: 'La catégorie doit avoir un nom et une couleur.'
+    })
   }
   try {
-        const result = await Categories.create({ name, color });
+    const result = await Categories.create({ name, color })
-        return res.status(201).json({ message: "La catégorie a bien été crée!", result });
+    return res
+      .status(201)
+      .json({ message: 'La catégorie a bien été crée!', result })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.putCategory = async (req, res, next) => {
-    const { name, color } = req.body;
+  const { name, color } = req.body
-    const { id }          = req.params;
+  const { id } = req.params
   if (!(name && color && id)) {
-        return errorHandling(next, { message: "La catégorie doit avoir un nom, une couleur et un id." });
+    return errorHandling(next, {
+      message: 'La catégorie doit avoir un nom, une couleur et un id.'
+    })
   }
   try {
-        const category = await Categories.findOne({ where: { id } });
+    const category = await Categories.findOne({ where: { id } })
     if (!category) {
-            return errorHandling(next, { message: "La catégorie n'existe pas." });
+      return errorHandling(next, { message: "La catégorie n'existe pas." })
     }
-        category.name = name;
+    category.name = name
-        category.color = color;
+    category.color = color
-        const result = await category.save();
+    const result = await category.save()
-        return res.status(200).json({ message: "La catégorie a bien été modifiée!", result });
+    return res
+      .status(200)
+      .json({ message: 'La catégorie a bien été modifiée!', result })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.deleteCategory = async (req, res, next) => {
-    const { id } = req.params;
+  const { id } = req.params
   try {
-        const category = await Categories.findOne({ where: { id } });
+    const category = await Categories.findOne({ where: { id } })
     if (!category) {
-            return errorHandling(next, { message: "La catégorie n'existe pas." });
+      return errorHandling(next, { message: "La catégorie n'existe pas." })
     }
-        await category.destroy();
+    await category.destroy()
-        return res.status(200).json({ message: "La catégorie a bien été supprimée!" });
+    return res
+      .status(200)
+      .json({ message: 'La catégorie a bien été supprimée!' })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.getQuotes = async (req, res, next) => {
   const options = {
     where: {
-            isValidated: 0,
+      isValidated: 0
     },
-        include: [
+    include: [{ model: Users, attributes: ['name', 'logo'] }],
-            { model: Users, attributes: ["name", "logo"] }
-        ],
     order: [['createdAt', 'DESC']]
-    };
+  }
-    return await getPagesHelper({ req, res, next }, Quotes, options);
+  return await getPagesHelper({ req, res, next }, Quotes, options)
 }
 
 exports.putQuote = async (req, res, next) => {
-    const { id }      = req.params;
+  const { id } = req.params
-    const { isValid } = req.body;
+  const { isValid } = req.body
   try {
     if (typeof isValid !== 'boolean') {
-            return errorHandling(next, { message: "isValid doit être un booléen.", statusCode: 400 });
+      return errorHandling(next, {
+        message: 'isValid doit être un booléen.',
+        statusCode: 400
+      })
     }
     const quote = await Quotes.findOne({
       where: {
         id,
         isValidated: 0
       },
-            include: [
+      include: [{ model: Users, attributes: ['name', 'email'] }]
-                { model: Users, attributes: ["name", "email"] }
+    })
-            ]
-        });
     if (!quote) {
-            return errorHandling(next, { message: "La citation n'existe pas (ou est déjà validé).", statusCode: 404 });
+      return errorHandling(next, {
+        message: "La citation n'existe pas (ou est déjà validé).",
+        statusCode: 404
+      })
     }
 
     await transporter.sendMail({
       from: `"FunctionProject" <${EMAIL_INFO.auth.user}>`,
       to: quote.user.email,
-            subject: "FunctionProject - Citation proposée",
+      subject: 'FunctionProject - Citation proposée',
       html: emailQuoteTemplate(isValid, quote, FRONT_END_HOST)
-        });
+    })
 
     if (isValid) {
-            quote.isValidated = true;
+      quote.isValidated = true
-            await quote.save();
+      await quote.save()
-            return res.status(200).json({ message: "La citation a bien été validée!" });
+      return res
+        .status(200)
+        .json({ message: 'La citation a bien été validée!' })
     } else {
-            await quote.destroy();
+      await quote.destroy()
-            return res.status(200).json({ imessage: "La citation a bien été supprimée!" });
+      return res
+        .status(200)
+        .json({ imessage: 'La citation a bien été supprimée!' })
     }
- 
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);   
+    return errorHandling(next, serverError)
   }
 }

api/controllers/categories.js

@@ -1,14 +1,14 @@
-const errorHandling   = require('../assets/utils/errorHandling');
+const errorHandling = require('../assets/utils/errorHandling')
-const Categories      = require('../models/categories');
+const Categories = require('../models/categories')
-const { serverError } = require('../assets/config/errors');
+const { serverError } = require('../assets/config/errors')
 
 exports.getCategories = (_req, res, next) => {
   Categories.findAll()
-        .then((result) => {
+    .then(result => {
-            res.status(200).json(result);
+      res.status(200).json(result)
+    })
+    .catch(error => {
+      console.log(error)
+      return errorHandling(next, serverError)
     })
-        .catch((error) => {
-            console.log(error);
-            return errorHandling(next, serverError);
-        });
 }

api/controllers/comments.js

@@ -1,72 +1,99 @@
-const errorHandling   = require('../assets/utils/errorHandling');
+const errorHandling = require('../assets/utils/errorHandling')
-const Comments        = require('../models/comments');
+const Comments = require('../models/comments')
-const Users           = require('../models/users');
+const Users = require('../models/users')
-const Functions       = require('../models/functions');
+const Functions = require('../models/functions')
-const getPagesHelper  = require('../assets/utils/getPagesHelper');
+const getPagesHelper = require('../assets/utils/getPagesHelper')
-const { serverError } = require('../assets/config/errors');
+const { serverError } = require('../assets/config/errors')
 
 exports.getCommentsByFunctionId = async (req, res, next) => {
-    const { functionId } = req.params;
+  const { functionId } = req.params
   const options = {
     where: { functionId },
-        include: [
+    include: [{ model: Users, attributes: ['name', 'logo'] }],
-            { model: Users, attributes: ["name", "logo"] }
-        ],
     order: [['createdAt', 'DESC']]
-    };
+  }
-    return await getPagesHelper({ req, res, next }, Comments, options);
+  return await getPagesHelper({ req, res, next }, Comments, options)
 }
 
 exports.postCommentsByFunctionId = async (req, res, next) => {
-    const { functionId } = req.params;
+  const { functionId } = req.params
-    const { message }    = req.body;
+  const { message } = req.body
   try {
-        const resultFunction = await Functions.findOne({ where: { id: functionId } });
+    const resultFunction = await Functions.findOne({
+      where: { id: functionId }
+    })
     if (!resultFunction) {
-            return errorHandling(next, { message: "La fonction n'existe pas.", statusCode: 404 });
+      return errorHandling(next, {
+        message: "La fonction n'existe pas.",
+        statusCode: 404
+      })
     }
     if (!message) {
-            return errorHandling(next, { message: "Vous ne pouvez pas poster de commentaire vide.", statusCode: 400 });
+      return errorHandling(next, {
+        message: 'Vous ne pouvez pas poster de commentaire vide.',
+        statusCode: 400
+      })
     }
-        const comment = await Comments.create({ message, userId: req.userId, functionId });
+    const comment = await Comments.create({
-        return res.status(201).json(comment);
+      message,
+      userId: req.userId,
+      functionId
+    })
+    return res.status(201).json(comment)
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);   
+    return errorHandling(next, serverError)
   }
 }
 
 exports.deleteCommentById = async (req, res, next) => {
-    const { commentId } = req.params;
+  const { commentId } = req.params
   try {
-        const comment = await Comments.findOne({ where: { userId: req.userId, id: parseInt(commentId) } });
+    const comment = await Comments.findOne({
+      where: { userId: req.userId, id: parseInt(commentId) }
+    })
     if (!comment) {
-            return errorHandling(next, { message: "Le commentaire n'existe pas.", statusCode: 404 });
+      return errorHandling(next, {
+        message: "Le commentaire n'existe pas.",
+        statusCode: 404
+      })
     }
-        await comment.destroy();
+    await comment.destroy()
-        return res.status(200).json({ message: "Le commentaire a bien été supprimé." });
+    return res
+      .status(200)
+      .json({ message: 'Le commentaire a bien été supprimé.' })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);   
+    return errorHandling(next, serverError)
   }
 }
 
 exports.putCommentsById = async (req, res, next) => {
-    const { commentId } = req.params;
+  const { commentId } = req.params
-    const { message }   = req.body;
+  const { message } = req.body
   if (!message) {
-        return errorHandling(next, { message: "Vous ne pouvez pas poster de commentaire vide.", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'Vous ne pouvez pas poster de commentaire vide.',
+      statusCode: 400
+    })
   }
   try {
-        const comment = await Comments.findOne({ where: { userId: req.userId, id: parseInt(commentId) } });
+    const comment = await Comments.findOne({
+      where: { userId: req.userId, id: parseInt(commentId) }
+    })
     if (!comment) {
-            return errorHandling(next, { message: "Le commentaire n'existe pas.", statusCode: 404 });
+      return errorHandling(next, {
+        message: "Le commentaire n'existe pas.",
+        statusCode: 404
+      })
     }
-        comment.message = message;
+    comment.message = message
-        await comment.save();
+    await comment.save()
-        return res.status(200).json({ message: "Le commentaire a bien été modifié." });
+    return res
+      .status(200)
+      .json({ message: 'Le commentaire a bien été modifié.' })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);   
+    return errorHandling(next, serverError)
   }
 }

api/controllers/favorites.js

@@ -1,74 +1,92 @@
-const errorHandling   = require('../assets/utils/errorHandling');
+const errorHandling = require('../assets/utils/errorHandling')
-const { serverError } = require('../assets/config/errors');
+const { serverError } = require('../assets/config/errors')
-const Favorites       = require('../models/favorites');
+const Favorites = require('../models/favorites')
-const Functions       = require('../models/functions');
+const Functions = require('../models/functions')
 
 exports.getFavoriteByFunctionId = async (req, res, next) => {
-    const { functionId } = req.params;
+  const { functionId } = req.params
-    const { userId }     = req;
+  const { userId } = req
   try {
     const favorite = await Favorites.findOne({
       where: {
         userId,
         functionId
       }
-        });
+    })
     if (!favorite) {
-            return res.status(200).json({ isFavorite: false });
+      return res.status(200).json({ isFavorite: false })
     }
-        return res.status(200).json({ isFavorite: true });
+    return res.status(200).json({ isFavorite: true })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.postFavoriteByFunctionId = async (req, res, next) => {
-    const { functionId } = req.params;
+  const { functionId } = req.params
-    const { userId }     = req;
+  const { userId } = req
   try {
-        const resultFunction = await Functions.findOne({ where: { id: functionId } });
+    const resultFunction = await Functions.findOne({
+      where: { id: functionId }
+    })
     if (!resultFunction) {
-            return errorHandling(next, { message: "La fonction n'existe pas.", statusCode: 404 });
+      return errorHandling(next, {
+        message: "La fonction n'existe pas.",
+        statusCode: 404
+      })
     }
     const favorite = await Favorites.findOne({
       where: {
         userId,
         functionId
       }
-        });
+    })
     if (!favorite) {
-            await Favorites.create({ userId, functionId });
+      await Favorites.create({ userId, functionId })
-            return res.status(201).json({ result: "Le favoris a bien été ajouté!" });
+      return res.status(201).json({ result: 'Le favoris a bien été ajouté!' })
     }
-        return errorHandling(next, { message: "La fonction est déjà en favoris.", statusCode: 400 });
+    return errorHandling(next, {
+      message: 'La fonction est déjà en favoris.',
+      statusCode: 400
+    })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.deleteFavoriteByFunctionId = async (req, res, next) => {
-    const { functionId } = req.params;
+  const { functionId } = req.params
-    const { userId }     = req;
+  const { userId } = req
   try {
-        const resultFunction = await Functions.findOne({ where: { id: functionId } });
+    const resultFunction = await Functions.findOne({
+      where: { id: functionId }
+    })
     if (!resultFunction) {
-            return errorHandling(next, { message: "La fonction n'existe pas.", statusCode: 404 });
+      return errorHandling(next, {
+        message: "La fonction n'existe pas.",
+        statusCode: 404
+      })
     }
     const favorite = await Favorites.findOne({
       where: {
         userId,
         functionId
       }
-        });
+    })
     if (!favorite) {
-            return errorHandling(next, { message: "Le fonction n'est pas en favoris.", statusCode: 400 });
+      return errorHandling(next, {
+        message: "Le fonction n'est pas en favoris.",
+        statusCode: 400
+      })
     }
-        await favorite.destroy();
+    await favorite.destroy()
-        return res.status(200).json({ message: "Le fonction a bien été supprimé des favoris." });
+    return res
+      .status(200)
+      .json({ message: 'Le fonction a bien été supprimé des favoris.' })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }

api/controllers/functions.js

@@ -1,69 +1,93 @@
-const errorHandling     = require('../assets/utils/errorHandling');
+const errorHandling = require('../assets/utils/errorHandling')
-const { serverError }   = require('../assets/config/errors');
+const { serverError } = require('../assets/config/errors')
-const Functions         = require('../models/functions');
+const Functions = require('../models/functions')
-const Categories        = require('../models/categories');
+const Categories = require('../models/categories')
-const functionToExecute = require('../assets/functions/functionObject');
+const functionToExecute = require('../assets/functions/functionObject')
-const helperQueryNumber = require('../assets/utils/helperQueryNumber');
+const helperQueryNumber = require('../assets/utils/helperQueryNumber')
-const getPagesHelper    = require('../assets/utils/getPagesHelper');
+const getPagesHelper = require('../assets/utils/getPagesHelper')
-const Sequelize         = require('sequelize');
+const Sequelize = require('sequelize')
 
 exports.getFunctions = async (req, res, next) => {
-    const categoryId = helperQueryNumber(req.query.categoryId, 0);
+  const categoryId = helperQueryNumber(req.query.categoryId, 0)
-    let   { search } = req.query;
+  let { search } = req.query
-    try { search = search.toLowerCase(); } catch {};
+  try {
+    search = search.toLowerCase()
+  } catch {}
   const options = {
     where: {
       isOnline: 1,
       // Trie par catégorie
-            ... (categoryId !== 0) && { categorieId: categoryId },
+      ...(categoryId !== 0 && { categorieId: categoryId }),
       // Recherche
-            ... (search != undefined) && { 
+      ...(search != null && {
         [Sequelize.Op.or]: [
-                    { title: Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('title')), 'LIKE', `%${search}%`) },
+          {
-                    { slug: Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('slug')), 'LIKE', `%${search}%`) },
+            title: Sequelize.where(
-                    { description: Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('description')), 'LIKE', `%${search}%`) }
+              Sequelize.fn('LOWER', Sequelize.col('title')),
-                ]
+              'LIKE',
-            }
+              `%${search}%`
+            )
           },
-        include: [
+          {
-            { model: Categories, attributes: ["name", "color"] }
+            slug: Sequelize.where(
-        ],
+              Sequelize.fn('LOWER', Sequelize.col('slug')),
+              'LIKE',
+              `%${search}%`
+            )
+          },
+          {
+            description: Sequelize.where(
+              Sequelize.fn('LOWER', Sequelize.col('description')),
+              'LIKE',
+              `%${search}%`
+            )
+          }
+        ]
+      })
+    },
+    include: [{ model: Categories, attributes: ['name', 'color'] }],
     attributes: {
-            exclude: ["updatedAt", "utilizationForm", "article", "isOnline"]
+      exclude: ['updatedAt', 'utilizationForm', 'article', 'isOnline']
     },
     order: [['createdAt', 'DESC']]
-    };
+  }
-    return await getPagesHelper({ req, res, next }, Functions, options);
+  return await getPagesHelper({ req, res, next }, Functions, options)
 }
 
 exports.getFunctionBySlug = (req, res, next) => {
-    const { slug } = req.params;
+  const { slug } = req.params
   Functions.findOne({
     where: { slug, isOnline: 1 },
     attributes: {
-            exclude: ["updatedAt", "isOnline"]
+      exclude: ['updatedAt', 'isOnline']
     },
-        include: [
+    include: [{ model: Categories, attributes: ['name', 'color'] }]
-            { model: Categories, attributes: ["name", "color"] }
-        ]
   })
-        .then((result) => {
+    .then(result => {
       if (!result) {
-                return errorHandling(next, { message: "La fonction n'existe pas.", statusCode: 404 });
+        return errorHandling(next, {
-            }
+          message: "La fonction n'existe pas.",
-            try { result.utilizationForm = JSON.parse(result.utilizationForm); } catch {}
+          statusCode: 404
-            return res.status(200).json(result);
+        })
+      }
+      try {
+        result.utilizationForm = JSON.parse(result.utilizationForm)
+      } catch {}
+      return res.status(200).json(result)
+    })
+    .catch(error => {
+      console.log(error)
+      return errorHandling(next, serverError)
     })
-        .catch((error) => {
-            console.log(error);
-            return errorHandling(next, serverError);
-        });
 }
 
 exports.executeFunctionBySlug = (req, res, next) => {
-    const functionOutput = functionToExecute(req.params.slug);
+  const functionOutput = functionToExecute(req.params.slug)
   if (functionOutput !== undefined) {
-        return functionOutput({ res, next }, req.body);
+    return functionOutput({ res, next }, req.body)
   }
-    return errorHandling(next, { message: "La fonction n'existe pas.", statusCode: 404 });
+  return errorHandling(next, {
+    message: "La fonction n'existe pas.",
+    statusCode: 404
+  })
 }

api/controllers/links_shortener.js

@@ -0,0 +1,191 @@
+const validator = require('validator')
+const errorHandling = require('../assets/utils/errorHandling')
+const { requiredFields, serverError } = require('../assets/config/errors')
+const ShortLinks = require('../models/short_links')
+const getPagesHelper = require('../assets/utils/getPagesHelper')
+const Sequelize = require('sequelize')
+
+const shortLinkBaseURL = 'https://s.divlo.fr'
+
+exports.getLinks = async (req, res, next) => {
+  const { userId } = req
+  const options = {
+    where: { userId },
+    order: [['createdAt', 'DESC']]
+  }
+  return await getPagesHelper({ req, res, next }, ShortLinks, options)
+}
+
+exports.postLink = async (req, res, next) => {
+  const { userId } = req
+  let { url, shortcutName } = req.body
+
+  // S'il n'y a pas les champs obligatoire
+  if (!(url && shortcutName)) {
+    return errorHandling(next, requiredFields)
+  }
+
+  // Si ce n'est pas une url
+  if (!validator.isURL(url)) {
+    return errorHandling(next, {
+      message: 'Veuillez entré une URL valide.',
+      statusCode: 400
+    })
+  }
+
+  // Si ce n'est pas de type slug
+  if (!validator.isSlug(shortcutName)) {
+    return errorHandling(next, {
+      message:
+        "Le nom de votre raccourci doit être de type slug (ne pas contenir d'espaces, ni de caractères spéciaux).",
+      statusCode: 400
+    })
+  }
+
+  // Sanitize shortcutName
+  shortcutName = validator.escape(shortcutName)
+  shortcutName = validator.trim(shortcutName)
+  shortcutName = validator.blacklist(shortcutName, ' ')
+
+  try {
+    // Si l'url a déjà été raccourcie
+    const urlInDatabase = await ShortLinks.findOne({ where: { url } })
+    if (urlInDatabase) {
+      const urlShort = `${shortLinkBaseURL}/${urlInDatabase.shortcut}`
+      return errorHandling(next, {
+        message: `L'url a déjà été raccourcie... <br/> <br/> <a target="_blank" rel="noopener noreferrer" href="${urlShort}">${urlShort}</a>`,
+        statusCode: 400
+      })
+    }
+
+    // Si le nom du raccourci existe déjà
+    const shortcutInDatabase = await ShortLinks.findOne({
+      where: { shortcut: shortcutName }
+    })
+    if (shortcutInDatabase) {
+      const urlShort = `${shortLinkBaseURL}/${shortcutInDatabase.shortcut}`
+      return errorHandling(next, {
+        message: `Le nom du raccourci a déjà été utilisé... <br/> <br/> <a target="_blank" rel="noopener noreferrer" href="${urlShort}">${urlShort}</a>`,
+        statusCode: 400
+      })
+    }
+
+    // Ajout du lien raccourci
+    const result = await ShortLinks.create({
+      url,
+      shortcut: shortcutName,
+      userId
+    })
+    const shortcutLinkResult = `${shortLinkBaseURL}/${result.shortcut}`
+    return res.status(200).json({
+      resultHTML: `URL Raccourcie : <br/> <br/> <a target="_blank" rel="noopener noreferrer" href="${shortcutLinkResult}">${shortcutLinkResult}</a>`,
+      result: shortcutLinkResult
+    })
+  } catch (error) {
+    console.log(error)
+    return errorHandling(next, serverError)
+  }
+}
+
+exports.putLink = async (req, res, next) => {
+  const { id } = req.params
+  const { userId } = req
+  let { url, shortcutName } = req.body
+
+  // S'il n'y a pas les champs obligatoire
+  if (!(url && shortcutName)) {
+    return errorHandling(next, requiredFields)
+  }
+
+  // Si ce n'est pas une url
+  if (!validator.isURL(url)) {
+    return errorHandling(next, {
+      message: 'Veuillez entré une URL valide.',
+      statusCode: 400
+    })
+  }
+
+  // Si ce n'est pas de type slug
+  if (!validator.isSlug(shortcutName)) {
+    return errorHandling(next, {
+      message:
+        "Le nom de votre raccourci doit être de type slug (ne pas contenir d'espaces, ni de caractères spéciaux).",
+      statusCode: 400
+    })
+  }
+
+  // Sanitize shortcutName
+  shortcutName = validator.escape(shortcutName)
+  shortcutName = validator.trim(shortcutName)
+  shortcutName = validator.blacklist(shortcutName, ' ')
+
+  try {
+    // Si l'url a déjà été raccourcie par quelqu'un d'autre
+    const urlInDatabase = await ShortLinks.findOne({
+      where: { url, [Sequelize.Op.not]: { userId } }
+    })
+    if (urlInDatabase) {
+      const urlShort = `${shortLinkBaseURL}/${urlInDatabase.shortcut}`
+      return errorHandling(next, {
+        message: `L'url a déjà été raccourcie... <br/> <br/> <a target="_blank" rel="noopener noreferrer" href="${urlShort}">${urlShort}</a>`,
+        statusCode: 400
+      })
+    }
+
+    // Si le nom du raccourci existe déjà par quelqu'un d'autre
+    const shortcutInDatabase = await ShortLinks.findOne({
+      where: { shortcut: shortcutName, [Sequelize.Op.not]: { userId } }
+    })
+    if (shortcutInDatabase) {
+      const urlShort = `${shortLinkBaseURL}/${shortcutInDatabase.shortcut}`
+      return errorHandling(next, {
+        message: `Le nom du raccourci a déjà été utilisé... <br/> <br/> <a target="_blank" rel="noopener noreferrer" href="${urlShort}">${urlShort}</a>`,
+        statusCode: 400
+      })
+    }
+
+    // Modification du lien raccourci
+    const result = await ShortLinks.findOne({
+      where: { id, userId }
+    })
+    console.log(result)
+    if (!result) {
+      return errorHandling(next, {
+        statusCode: 404,
+        message: "Le raccourci n'existe pas..."
+      })
+    }
+    result.url = url
+    result.shortcut = shortcutName
+    const { shortcut } = await result.save()
+    const shortcutLinkResult = `${shortLinkBaseURL}/${shortcut}`
+    return res.status(200).json({
+      resultHTML: `URL Raccourcie : <br/> <br/> <a target="_blank" rel="noopener noreferrer" href="${shortcutLinkResult}">${shortcutLinkResult}</a>`,
+      result: shortcutLinkResult
+    })
+  } catch (error) {
+    console.log(error)
+    return errorHandling(next, serverError)
+  }
+}
+
+exports.deleteLink = async (req, res, next) => {
+  const { id } = req.params
+  const { userId } = req
+  try {
+    const linkResult = await ShortLinks.findOne({
+      where: { id, userId }
+    })
+    if (!linkResult) {
+      return errorHandling(next, {
+        message: "Le lien raccourci n'existe pas.",
+        statusCode: 404
+      })
+    }
+    await linkResult.destroy()
+    return res.status(200).json({ message: 'La lien a bien été supprimé!' })
+  } catch (error) {
+    console.log(error)
+    return errorHandling(next, serverError)
+  }
+}

api/controllers/quotes.js

@@ -1,37 +1,40 @@
-const errorHandling                   = require('../assets/utils/errorHandling');
+const errorHandling = require('../assets/utils/errorHandling')
-const { serverError, requiredFields } = require('../assets/config/errors');
+const { serverError, requiredFields } = require('../assets/config/errors')
-const Quotes                          = require('../models/quotes');
+const Quotes = require('../models/quotes')
-const Users                           = require('../models/users');
+const Users = require('../models/users')
-const getPagesHelper                  = require('../assets/utils/getPagesHelper');
+const getPagesHelper = require('../assets/utils/getPagesHelper')
 
 exports.getQuotes = async (req, res, next) => {
   const options = {
     where: {
-            isValidated: 1,
+      isValidated: 1
     },
-        include: [
+    include: [{ model: Users, attributes: ['name', 'logo'] }],
-            { model: Users, attributes: ["name", "logo"] }
-        ],
     attributes: {
-            exclude: ["isValidated"]
+      exclude: ['isValidated']
     },
     order: [['createdAt', 'DESC']]
-    };
+  }
-    return await getPagesHelper({ req, res, next }, Quotes, options);
+  return await getPagesHelper({ req, res, next }, Quotes, options)
 }
 
 exports.postQuote = (req, res, next) => {
-    const { quote, author } = req.body;
+  const { quote, author } = req.body
   // S'il n'y a pas les champs obligatoire
   if (!(quote && author)) {
-        return errorHandling(next, requiredFields);
+    return errorHandling(next, requiredFields)
   }
   Quotes.create({ quote, author, userId: req.userId })
-        .then((_result) => {
+    .then(_result => {
-            return res.status(200).json({ message: "La citation a bien été ajoutée, elle est en attente de confirmation d'un administrateur." });
+      return res
+        .status(200)
+        .json({
+          message:
+            "La citation a bien été ajoutée, elle est en attente de confirmation d'un administrateur."
+        })
+    })
+    .catch(error => {
+      console.log(error)
+      return errorHandling(next, serverError)
     })
-        .catch((error) => {
-            console.log(error);
-            return errorHandling(next, serverError);
-        });
 }

api/controllers/tasks.js

@@ -1,6 +1,6 @@
-const errorHandling                   = require('../assets/utils/errorHandling');
+const errorHandling = require('../assets/utils/errorHandling')
-const { serverError, requiredFields } = require('../assets/config/errors');
+const { serverError, requiredFields } = require('../assets/config/errors')
-const Tasks                           = require('../models/tasks');
+const Tasks = require('../models/tasks')
 
 exports.getTasks = async (req, res, next) => {
   try {
@@ -9,60 +9,75 @@ exports.getTasks = async (req, res, next) => {
         userId: req.userId
       },
       order: [['createdAt', 'DESC']]
-        });
+    })
-        return res.status(200).json(tasks);
+    return res.status(200).json(tasks)
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.postTask = async (req, res, next) => {
-    const { task } = req.body;
+  const { task } = req.body
   try {
     if (!task) {
-            return errorHandling(next, requiredFields);
+      return errorHandling(next, requiredFields)
     }
-        const taskResult = await Tasks.create({ task, userId: req.userId });
+    const taskResult = await Tasks.create({ task, userId: req.userId })
-        return res.status(201).json(taskResult);
+    return res.status(201).json(taskResult)
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.putTask = async (req, res, next) => {
-    const { id }          = req.params;
+  const { id } = req.params
-    const { isCompleted } = req.body;
+  const { isCompleted } = req.body
   try {
     if (typeof isCompleted !== 'boolean') {
-            return errorHandling(next, { message: "isCompleted doit être un booléen.", statusCode: 400 });
+      return errorHandling(next, {
+        message: 'isCompleted doit être un booléen.',
+        statusCode: 400
+      })
     }
 
-        const taskResult = await Tasks.findOne({ where: { id, userId: req.userId } });
+    const taskResult = await Tasks.findOne({
+      where: { id, userId: req.userId }
+    })
     if (!taskResult) {
-            return errorHandling(next, { message: `La "tâche à faire" n'existe pas.`, statusCode: 404 });
+      return errorHandling(next, {
+        message: 'La "tâche à faire" n\'existe pas.',
+        statusCode: 404
+      })
     }
-        taskResult.isCompleted = isCompleted;
+    taskResult.isCompleted = isCompleted
-        const taskSaved = await taskResult.save();
+    const taskSaved = await taskResult.save()
-        return res.status(200).json(taskSaved);
+    return res.status(200).json(taskSaved)
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.deleteTask = async (req, res, next) => {
-    const { id } = req.params;
+  const { id } = req.params
   try {
-        const taskResult = await Tasks.findOne({ where: { id, userId: req.userId } });
+    const taskResult = await Tasks.findOne({
+      where: { id, userId: req.userId }
+    })
     if (!taskResult) {
-            return errorHandling(next, { message: `La "tâche à faire" n'existe pas.`, statusCode: 404 });
+      return errorHandling(next, {
+        message: 'La "tâche à faire" n\'existe pas.',
+        statusCode: 404
+      })
     }
-        await taskResult.destroy();
+    await taskResult.destroy()
-        return res.status(200).json({ message: `La "tâche à faire" a bien été supprimée!` });
+    return res
+      .status(200)
+      .json({ message: 'La "tâche à faire" a bien été supprimée!' })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }

api/controllers/users.js

@@ -1,280 +1,442 @@
-const path                                                         = require('path');
+const path = require('path')
-const { validationResult }                                         = require('express-validator');
+const { validationResult } = require('express-validator')
-const bcrypt                                                       = require('bcryptjs');
+const bcrypt = require('bcryptjs')
-const jwt                                                          = require('jsonwebtoken');
+const jwt = require('jsonwebtoken')
-const ms                                                           = require('ms');
+const ms = require('ms')
-const uuid                                                         = require('uuid');
+const uuid = require('uuid')
-const Sequelize                                                    = require('sequelize');
+const Sequelize = require('sequelize')
-const errorHandling                                                = require('../assets/utils/errorHandling');
+const errorHandling = require('../assets/utils/errorHandling')
-const { serverError, generalError }                                = require('../assets/config/errors');
+const { serverError, generalError } = require('../assets/config/errors')
-const { JWT_SECRET, FRONT_END_HOST, EMAIL_INFO, HOST, TOKEN_LIFE } = require('../assets/config/config');
+const {
-const transporter                                                  = require('../assets/config/transporter');
+  JWT_SECRET,
-const { emailUserTemplate }                                        = require('../assets/config/emails');
+  FRONT_END_HOST,
-const Users                                                        = require('../models/users');
+  EMAIL_INFO,
-const Favorites                                                    = require('../models/favorites');
+  HOST,
-const Functions                                                    = require('../models/functions');
+  TOKEN_LIFE
-const Categories                                                   = require('../models/categories');
+} = require('../assets/config/config')
-const Comments                                                     = require('../models/comments');
+const transporter = require('../assets/config/transporter')
-const Quotes                                                       = require('../models/quotes');
+const { emailUserTemplate } = require('../assets/config/emails')
-const deleteFilesNameStartWith                                     = require('../assets/utils/deleteFilesNameStartWith');
+const Users = require('../models/users')
-const getPagesHelper                                               = require('../assets/utils/getPagesHelper');
+const Favorites = require('../models/favorites')
+const Functions = require('../models/functions')
+const Categories = require('../models/categories')
+const Comments = require('../models/comments')
+const Quotes = require('../models/quotes')
+const deleteFilesNameStartWith = require('../assets/utils/deleteFilesNameStartWith')
+const getPagesHelper = require('../assets/utils/getPagesHelper')
 
-async function handleEditUser(res, { name, email, biography, isPublicEmail }, userId, logoName) {
+async function handleEditUser (
-    const user = await Users.findOne({ where: { id: userId } });
+  res,
-    user.name = name;
+  { name, email, biography, isPublicEmail },
+  userId,
+  logoName
+) {
+  const user = await Users.findOne({ where: { id: userId } })
+  user.name = name
   if (user.email !== email) {
-        const tempToken = uuid.v4();
+    const tempToken = uuid.v4()
-        user.email = email;
+    user.email = email
-        user.isConfirmed = false;
+    user.isConfirmed = false
-        user.tempToken = tempToken;
+    user.tempToken = tempToken
     await transporter.sendMail({
       from: `"FunctionProject" <${EMAIL_INFO.auth.user}>`,
       to: email,
       subject: "FunctionProject - Confirmer l'email",
-            html: emailUserTemplate("Veuillez confirmer l'email", "Oui, je confirme.", `${HOST}/users/confirm-email/${tempToken}`, "Si vous avez reçu ce message par erreur, il suffit de le supprimer. Votre email ne serez pas confirmé si vous ne cliquez pas sur le lien de confirmation ci-dessus.")
+      html: emailUserTemplate(
-        });
+        "Veuillez confirmer l'email",
+        'Oui, je confirme.',
+        `${HOST}/users/confirm-email/${tempToken}`,
+        'Si vous avez reçu ce message par erreur, il suffit de le supprimer. Votre email ne serez pas confirmé si vous ne cliquez pas sur le lien de confirmation ci-dessus.'
+      )
+    })
   }
-    if (biography != undefined) {
+  if (biography != null) {
-        user.biography = biography;
+    user.biography = biography
   }
-    user.isPublicEmail = isPublicEmail;
+  user.isPublicEmail = isPublicEmail
-    if (logoName != undefined && `/images/users/${logoName}` !== user.logo) {
+  if (logoName != null && `/images/users/${logoName}` !== user.logo) {
-        user.logo = `/images/users/${logoName}`;
+    user.logo = `/images/users/${logoName}`
   }
-    await user.save();
+  await user.save()
-    return res.status(200).json({ id: user.id, name: user.name, email: user.email, biography: user.biography, logo: user.logo, isPublicEmail: user.isPublicEmail, isAdmin: user.isAdmin, createdAt: user.createdAt });
+  return res
+    .status(200)
+    .json({
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      biography: user.biography,
+      logo: user.logo,
+      isPublicEmail: user.isPublicEmail,
+      isAdmin: user.isAdmin,
+      createdAt: user.createdAt
+    })
 }
 
 exports.getUsers = async (req, res, next) => {
-    let { search } = req.query;
+  let { search } = req.query
-    try { search = search.toLowerCase(); } catch {};
+  try {
+    search = search.toLowerCase()
+  } catch {}
   const options = {
     where: {
       isConfirmed: true,
       // Recherche
-            ...(search != undefined) && {
+      ...(search != null && {
-                name: Sequelize.where(Sequelize.fn('LOWER', Sequelize.col('name')), 'LIKE', `%${search}%`)
+        name: Sequelize.where(
-            }
+          Sequelize.fn('LOWER', Sequelize.col('name')),
+          'LIKE',
+          `%${search}%`
+        )
+      })
     },
     attributes: {
-            exclude: ["updatedAt", "isAdmin", "isConfirmed", "password", "tempToken", "tempExpirationToken", "isPublicEmail", "email"]
+      exclude: [
+        'updatedAt',
+        'isAdmin',
+        'isConfirmed',
+        'password',
+        'tempToken',
+        'tempExpirationToken',
+        'isPublicEmail',
+        'email'
+      ]
     },
     order: [['createdAt', 'DESC']]
-    };
+  }
-    return await getPagesHelper({ req, res, next }, Users, options);
+  return await getPagesHelper({ req, res, next }, Users, options)
 }
 
 exports.putUser = async (req, res, next) => {
-    const { name, email, biography, isPublicEmail } = req.body;
+  const { name, email, biography, isPublicEmail } = req.body
-    const logo = req.files.logo;
+  const logo = req.files.logo
-    const errors = validationResult(req);
+  const errors = validationResult(req)
   if (!errors.isEmpty()) {
-        return errorHandling(next, { message: errors.array()[0].msg, statusCode: 400 });
+    return errorHandling(next, {
+      message: errors.array()[0].msg,
+      statusCode: 400
+    })
   }
-    if (logo != undefined) {
+  if (logo != null) {
-        if (!logo || logo.truncated && (
+    if (
-            logo.mimetype !== 'image/png' || 
+      (!logo || logo.truncated) &&
+      (logo.mimetype !== 'image/png' ||
         logo.mimetype !== 'image/jpg' ||
         logo.mimetype !== 'image/jpeg' ||
-            logo.mimetype !== 'image/gif'
+        logo.mimetype !== 'image/gif')
-        )) {
+    ) {
-            return errorHandling(next, { message:"Le profil doit avoir une image valide (PNG, JPG, GIF) et moins de 5mo.", statusCode: 400 });
+      return errorHandling(next, {
+        message:
+          'Le profil doit avoir une image valide (PNG, JPG, GIF) et moins de 5mo.',
+        statusCode: 400
+      })
     }
-        const splitedLogoName = logo.name.split('.');
+    const splitedLogoName = logo.name.split('.')
-        if (splitedLogoName.length !== 2) return errorHandling(next, serverError);
+    if (splitedLogoName.length !== 2) return errorHandling(next, serverError)
-        const logoName = name + req.userId + '.' + splitedLogoName[1];
+    const logoName = name + req.userId + '.' + splitedLogoName[1]
     // Supprime les anciens logo
     try {
-            deleteFilesNameStartWith(`${name + req.userId}`, path.join(__dirname, '..', 'assets', 'images', 'users'), async () => {
+      deleteFilesNameStartWith(
-                logo.mv(path.join(__dirname, '..', 'assets', 'images', 'users', logoName), async (error) => {
+        `${name + req.userId}`,
-                    if (error) return errorHandling(next, serverError);
+        path.join(__dirname, '..', 'assets', 'images', 'users'),
-                    return await handleEditUser(res, { name, email, biography, isPublicEmail }, req.userId, logoName);
+        async () => {
-                });
+          logo.mv(
-            });
+            path.join(__dirname, '..', 'assets', 'images', 'users', logoName),
+            async error => {
+              if (error) return errorHandling(next, serverError)
+              return await handleEditUser(
+                res,
+                { name, email, biography, isPublicEmail },
+                req.userId,
+                logoName
+              )
+            }
+          )
+        }
+      )
     } catch (error) {
-            console.log(error);
+      console.log(error)
-            return errorHandling(next, serverError);
+      return errorHandling(next, serverError)
     }
   } else {
     try {
-            return await handleEditUser(res, { name, email, biography, isPublicEmail }, req.userId, null);
+      return await handleEditUser(
+        res,
+        { name, email, biography, isPublicEmail },
+        req.userId,
+        null
+      )
     } catch (error) {
-            console.log(error);
+      console.log(error)
-            return errorHandling(next, serverError);
+      return errorHandling(next, serverError)
     }
   }
 }
 
 exports.register = async (req, res, next) => {
-    const { name, email, password } = req.body;
+  const { name, email, password } = req.body
-    const errors = validationResult(req);
+  const errors = validationResult(req)
   if (!errors.isEmpty()) {
-        return errorHandling(next, { message: errors.array()[0].msg, statusCode: 400 });
+    return errorHandling(next, {
+      message: errors.array()[0].msg,
+      statusCode: 400
+    })
   }
   try {
-        const hashedPassword = await bcrypt.hash(password, 12);
+    const hashedPassword = await bcrypt.hash(password, 12)
-        const tempToken = uuid.v4();
+    const tempToken = uuid.v4()
-        await Users.create({ email, name, password: hashedPassword, tempToken });
+    await Users.create({ email, name, password: hashedPassword, tempToken })
     await transporter.sendMail({
       from: `"FunctionProject" <${EMAIL_INFO.auth.user}>`,
       to: email,
       subject: "FunctionProject - Confirmer l'inscription",
-            html: emailUserTemplate("Veuillez confirmer l'inscription", "Oui, je m'inscris.", `${HOST}/users/confirm-email/${tempToken}`, "Si vous avez reçu ce message par erreur, il suffit de le supprimer. Vous ne serez pas inscrit si vous ne cliquez pas sur le lien de confirmation ci-dessus.")
+      html: emailUserTemplate(
-        });
+        "Veuillez confirmer l'inscription",
-        return res.status(201).json({ result: "Vous y êtes presque, veuillez vérifier vos emails pour confirmer l'inscription." });
+        "Oui, je m'inscris.",
+        `${HOST}/users/confirm-email/${tempToken}`,
+        'Si vous avez reçu ce message par erreur, il suffit de le supprimer. Vous ne serez pas inscrit si vous ne cliquez pas sur le lien de confirmation ci-dessus.'
+      )
+    })
+    return res
+      .status(201)
+      .json({
+        result:
+          "Vous y êtes presque, veuillez vérifier vos emails pour confirmer l'inscription."
+      })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.login = async (req, res, next) => {
-    const { email, password } = req.body;
+  const { email, password } = req.body
-    const errors = validationResult(req);
+  const errors = validationResult(req)
   if (!errors.isEmpty()) {
-        return errorHandling(next, { message: errors.array()[0].msg, statusCode: 400 });
+    return errorHandling(next, {
+      message: errors.array()[0].msg,
+      statusCode: 400
+    })
   }
   try {
-        const user = await Users.findOne({ where: { email } });
+    const user = await Users.findOne({ where: { email } })
     if (!user) {
-            return errorHandling(next, { message: "Le mot de passe ou l'adresse email n'est pas valide.", statusCode: 400 });
+      return errorHandling(next, {
+        message: "Le mot de passe ou l'adresse email n'est pas valide.",
+        statusCode: 400
+      })
     }
-        const isEqual = await bcrypt.compare(password, user.password);
+    const isEqual = await bcrypt.compare(password, user.password)
     if (!isEqual) {
-            return errorHandling(next, { message: "Le mot de passe ou l'adresse email n'est pas valide.", statusCode: 400 });
+      return errorHandling(next, {
+        message: "Le mot de passe ou l'adresse email n'est pas valide.",
+        statusCode: 400
+      })
     }
     if (!user.isConfirmed) {
-            return errorHandling(next, { message: "Vous devez valider votre adresse email pour votre première connexion.", statusCode: 400 });
+      return errorHandling(next, {
+        message:
+          'Vous devez valider votre adresse email pour votre première connexion.',
+        statusCode: 400
+      })
     }
-        const token = jwt.sign({ 
+    const token = jwt.sign(
-            email: user.email, userId: user.id
+      {
-        }, JWT_SECRET, { expiresIn: TOKEN_LIFE });
+        email: user.email,
-        return res.status(200).json({ token, id: user.id, name: user.name, email: user.email, biography: user.biography, logo: user.logo, isPublicEmail: user.isPublicEmail, isAdmin: user.isAdmin, createdAt: user.createdAt, expiresIn: Math.round(ms(TOKEN_LIFE) / 1000) });
+        userId: user.id
+      },
+      JWT_SECRET,
+      { expiresIn: TOKEN_LIFE }
+    )
+    return res
+      .status(200)
+      .json({
+        token,
+        id: user.id,
+        name: user.name,
+        email: user.email,
+        biography: user.biography,
+        logo: user.logo,
+        isPublicEmail: user.isPublicEmail,
+        isAdmin: user.isAdmin,
+        createdAt: user.createdAt,
+        expiresIn: Math.round(ms(TOKEN_LIFE) / 1000)
+      })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.confirmEmail = async (req, res, next) => {
-    const { tempToken } = req.params;
+  const { tempToken } = req.params
   if (!tempToken) {
-        return errorHandling(next, generalError);
+    return errorHandling(next, generalError)
   }
   try {
-        const user = await Users.findOne({ where: { tempToken, isConfirmed: false } });
+    const user = await Users.findOne({
+      where: { tempToken, isConfirmed: false }
+    })
     if (!user) {
-            return errorHandling(next, { message: "Le token n'est pas valide.", statusCode: 400 });
+      return errorHandling(next, {
+        message: "Le token n'est pas valide.",
+        statusCode: 400
+      })
     }
-        user.tempToken = null;
+    user.tempToken = null
-        user.isConfirmed = true;
+    user.isConfirmed = true
-        await user.save();
+    await user.save()
-        return res.redirect(`${FRONT_END_HOST}/users/login?isConfirmed=true`);
+    return res.redirect(`${FRONT_END_HOST}/users/login?isConfirmed=true`)
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.resetPassword = async (req, res, next) => {
-    const { email } = req.body;
+  const { email } = req.body
-    const errors = validationResult(req);
+  const errors = validationResult(req)
   if (!errors.isEmpty()) {
-        return errorHandling(next, { message: errors.array()[0].msg, statusCode: 400 });
+    return errorHandling(next, {
+      message: errors.array()[0].msg,
+      statusCode: 400
+    })
   }
   try {
-        const user = await Users.findOne({ where: { email, tempToken: null } });
+    const user = await Users.findOne({ where: { email, tempToken: null } })
     if (!user) {
-            return errorHandling(next, { message: "L'adresse email n'existe pas ou une demande est déjà en cours.", statusCode: 400 });
+      return errorHandling(next, {
+        message:
+          "L'adresse email n'existe pas ou une demande est déjà en cours.",
+        statusCode: 400
+      })
     }
-        const tempToken = uuid.v4();
+    const tempToken = uuid.v4()
-        user.tempExpirationToken = Date.now() + 3600000; // 1 heure
+    user.tempExpirationToken = Date.now() + 3600000 // 1 heure
-        user.tempToken = tempToken;
+    user.tempToken = tempToken
-        await user.save();
+    await user.save()
     await transporter.sendMail({
       from: `"FunctionProject" <${EMAIL_INFO.auth.user}>`,
       to: email,
-            subject: "FunctionProject - Réinitialisation du mot de passe",
+      subject: 'FunctionProject - Réinitialisation du mot de passe',
-            html: emailUserTemplate("Veuillez confirmer la réinitialisation du mot de passe", "Oui, je change mon mot de passe.", `${FRONT_END_HOST}/users/newPassword?token=${tempToken}`, "Si vous avez reçu ce message par erreur, il suffit de le supprimer. Votre mot de passe ne sera pas réinitialiser si vous ne cliquez pas sur le lien ci-dessus. Par ailleurs, pour la sécurité de votre compte, la réinitialisation du mot de passe est disponible pendant un délai de 1 heure, passez ce temps, la réinitialisation ne sera plus valide.")
+      html: emailUserTemplate(
-        });
+        'Veuillez confirmer la réinitialisation du mot de passe',
-        return res.status(200).json({ result: "Demande de réinitialisation du mot de passe réussi, veuillez vérifier vos emails!" });
+        'Oui, je change mon mot de passe.',
+        `${FRONT_END_HOST}/users/newPassword?token=${tempToken}`,
+        'Si vous avez reçu ce message par erreur, il suffit de le supprimer. Votre mot de passe ne sera pas réinitialiser si vous ne cliquez pas sur le lien ci-dessus. Par ailleurs, pour la sécurité de votre compte, la réinitialisation du mot de passe est disponible pendant un délai de 1 heure, passez ce temps, la réinitialisation ne sera plus valide.'
+      )
+    })
+    return res
+      .status(200)
+      .json({
+        result:
+          'Demande de réinitialisation du mot de passe réussi, veuillez vérifier vos emails!'
+      })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.newPassword = async (req, res, next) => {
-    const { tempToken, password } = req.body;
+  const { tempToken, password } = req.body
-    const errors = validationResult(req);
+  const errors = validationResult(req)
   if (!errors.isEmpty()) {
-        return errorHandling(next, { message: errors.array()[0].msg, statusCode: 400 });
+    return errorHandling(next, {
+      message: errors.array()[0].msg,
+      statusCode: 400
+    })
   }
   try {
-        const user = await Users.findOne({ where: { tempToken } });
+    const user = await Users.findOne({ where: { tempToken } })
-        if (!user && parseInt(tempExpirationToken) < Date.now()) {
+    if (!user && parseInt(user.tempExpirationToken) < Date.now()) {
-            return errorHandling(next, { message: "Le token n'est pas valide.", statusCode: 400 });
+      return errorHandling(next, {
+        message: "Le token n'est pas valide.",
+        statusCode: 400
+      })
     }
-        const hashedPassword = await bcrypt.hash(password, 12);
+    const hashedPassword = await bcrypt.hash(password, 12)
-        user.password = hashedPassword;
+    user.password = hashedPassword
-        user.tempToken = null;
+    user.tempToken = null
-        user.tempExpirationToken = null;
+    user.tempExpirationToken = null
-        await user.save();
+    await user.save()
-        return res.status(200).json({ result: "Le mot de passe a bien été modifié!" });
+    return res
+      .status(200)
+      .json({ result: 'Le mot de passe a bien été modifié!' })
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }
 
 exports.getUserInfo = async (req, res, next) => {
-    const { name } = req.params;
+  const { name } = req.params
   try {
     const user = await Users.findOne({
       where: { name, isConfirmed: true },
       attributes: {
-                exclude: ["updatedAt", "isAdmin", "isConfirmed", "password", "tempToken", "tempExpirationToken"]
+        exclude: [
-            }, 
+          'updatedAt',
-        });
+          'isAdmin',
+          'isConfirmed',
+          'password',
+          'tempToken',
+          'tempExpirationToken'
+        ]
+      }
+    })
     if (!user) {
-            return errorHandling(next, { message: "L'utilisateur n'existe pas.", statusCode: 404 });
+      return errorHandling(next, {
+        message: "L'utilisateur n'existe pas.",
+        statusCode: 404
+      })
     }
     const favorites = await Favorites.findAll({
       where: { userId: user.id },
       include: [
-                { model: Functions, attributes: { exclude: ["updatedAt", "utilizationForm", "article", "isOnline"] }, include: { model: Categories, attributes: ["name", "color"] } }
+        {
+          model: Functions,
+          attributes: {
+            exclude: ['updatedAt', 'utilizationForm', 'article', 'isOnline']
+          },
+          include: { model: Categories, attributes: ['name', 'color'] }
+        }
       ],
       order: [['createdAt', 'DESC']],
       limit: 5
-        });
+    })
-        const favoritesArray = favorites.map((favorite) => favorite.function);
+    const favoritesArray = favorites.map(favorite => favorite.function)
     const comments = await Comments.findAll({
       where: { userId: user.id },
       include: [
-                { model: Functions, attributes: { exclude: ["updatedAt", "utilizationForm", "article", "isOnline"] } }
+        {
+          model: Functions,
+          attributes: {
+            exclude: ['updatedAt', 'utilizationForm', 'article', 'isOnline']
+          }
+        }
       ],
       order: [['createdAt', 'DESC']],
       limit: 5
-        });
+    })
-        const commentsArray = comments.map((commentObject) => {
+    const commentsArray = comments.map(commentObject => {
       return {
         id: commentObject.id,
         message: commentObject.message,
         createdAt: commentObject.createdAt,
         function: commentObject.function.dataValues
-            };
+      }
-        });
+    })
     const quotesArray = await Quotes.findAll({
-            where: { userId: user.id },
+      where: { userId: user.id, isValidated: 1 },
       attributes: {
-                exclude: ["updatedAt", "createdAt", "isValidated", "userId", "id"]
+        exclude: ['updatedAt', 'createdAt', 'isValidated', 'userId', 'id']
       },
       order: [['createdAt', 'DESC']],
-            limit: 5,
+      limit: 5
-        });
+    })
     const userObject = {
       // Si Public Email
-            ... (user.isPublicEmail) && { email: user.email },
+      ...(user.isPublicEmail && { email: user.email }),
       isPublicEmail: user.isPublicEmail,
       name: user.name,
       biography: user.biography,
@@ -283,10 +445,10 @@ exports.getUserInfo = async (req, res, next) => {
       favoritesArray,
       commentsArray,
       quotesArray
-        };
+    }
-        return res.status(200).json(userObject);
+    return res.status(200).json(userObject)
   } catch (error) {
-        console.log(error);
+    console.log(error)
-        return errorHandling(next, serverError);
+    return errorHandling(next, serverError)
   }
 }

api/middlewares/isAdmin.js

@@ -1,23 +1,32 @@
-const errorHandling   = require('../assets/utils/errorHandling');
+const errorHandling = require('../assets/utils/errorHandling')
-const { serverError } = require('../assets/config/errors');
+const { serverError } = require('../assets/config/errors')
-const Users           = require('../models/users');
+const Users = require('../models/users')
 
 module.exports = (req, _res, next) => {
   if (!req.userId) {
-        return errorHandling(next, { message: "Vous n'êtes pas connecté.", statusCode: 403 });
+    return errorHandling(next, {
+      message: "Vous n'êtes pas connecté.",
+      statusCode: 403
+    })
   }
   Users.findOne({ where: { id: req.userId } })
-        .then((user) => {
+    .then(user => {
       if (!user) {
-                return errorHandling(next, { message: "Le mot de passe ou l'adresse email n'est pas valide.", statusCode: 403 });
+        return errorHandling(next, {
+          message: "Le mot de passe ou l'adresse email n'est pas valide.",
+          statusCode: 403
+        })
       }
       if (!user.isAdmin) {
-                return errorHandling(next, { message: "Vous n'êtes pas administrateur.", statusCode: 403 });
+        return errorHandling(next, {
-            }
+          message: "Vous n'êtes pas administrateur.",
-            next();
+          statusCode: 403
+        })
+      }
+      next()
+    })
+    .catch(error => {
+      console.log(error)
+      return errorHandling(next, serverError)
     })
-        .catch((error) => {
-            console.log(error);
-            return errorHandling(next, serverError);
-        });
 }

api/middlewares/isAuth.js

@@ -1,24 +1,33 @@
-const jwt             = require('jsonwebtoken');
+const jwt = require('jsonwebtoken')
-const errorHandling   = require('../assets/utils/errorHandling');
+const errorHandling = require('../assets/utils/errorHandling')
-const { JWT_SECRET }  = require('../assets/config/config');
+const { JWT_SECRET } = require('../assets/config/config')
 
 module.exports = (req, _res, next) => {
-    const token = req.get('Authorization');
+  const token = req.get('Authorization')
   if (!token) {
-        return errorHandling(next, { message: "Vous devez être connecter pour effectuer cette opération.", statusCode: 403 });
+    return errorHandling(next, {
+      message: 'Vous devez être connecter pour effectuer cette opération.',
+      statusCode: 403
+    })
   }
 
-    let decodedToken;
+  let decodedToken
   try {
-        decodedToken = jwt.verify(token, JWT_SECRET);
+    decodedToken = jwt.verify(token, JWT_SECRET)
   } catch (error) {
-        return errorHandling(next, { message: "Vous devez être connecter pour effectuer cette opération.", statusCode: 403 });
+    return errorHandling(next, {
+      message: 'Vous devez être connecter pour effectuer cette opération.',
+      statusCode: 403
+    })
   }
 
   if (!decodedToken) {
-        return errorHandling(next, { message: "Vous devez être connecter pour effectuer cette opération.", statusCode: 403 });
+    return errorHandling(next, {
+      message: 'Vous devez être connecter pour effectuer cette opération.',
+      statusCode: 403
+    })
   }
 
-    req.userId = decodedToken.userId;
+  req.userId = decodedToken.userId
-    next();
+  next()
 }

api/models/categories.js

@@ -1,13 +1,13 @@
-const Sequelize = require('sequelize');
+const Sequelize = require('sequelize')
-const sequelize = require('../assets/utils/database');
+const sequelize = require('../assets/utils/database')
 
 module.exports = sequelize.define('categorie', {
   name: {
     type: Sequelize.STRING,
-        allowNull: false,
+    allowNull: false
   },
   color: {
     type: Sequelize.STRING,
-        allowNull: false,
+    allowNull: false
   }
-});
+})

api/models/comments.js

@@ -1,9 +1,9 @@
-const Sequelize = require('sequelize');
+const Sequelize = require('sequelize')
-const sequelize = require('../assets/utils/database');
+const sequelize = require('../assets/utils/database')
 
 module.exports = sequelize.define('comment', {
   message: {
     type: Sequelize.TEXT,
     allowNull: false
   }
-});
+})

api/models/favorites.js

@@ -1,4 +1,3 @@
-const Sequelize = require('sequelize');
+const sequelize = require('../assets/utils/database')
-const sequelize = require('../assets/utils/database');
 
-module.exports = sequelize.define('favorite', {});
+module.exports = sequelize.define('favorite', {})

api/models/functions.js

@@ -1,14 +1,14 @@
-const Sequelize = require('sequelize');
+const Sequelize = require('sequelize')
-const sequelize = require('../assets/utils/database');
+const sequelize = require('../assets/utils/database')
 
 module.exports = sequelize.define('function', {
   title: {
     type: Sequelize.STRING,
-        allowNull: false,
+    allowNull: false
   },
   slug: {
     type: Sequelize.STRING,
-        allowNull: false,
+    allowNull: false
   },
   description: {
     type: Sequelize.STRING,
@@ -17,7 +17,7 @@ module.exports = sequelize.define('function', {
   image: {
     type: Sequelize.STRING,
     allowNull: false,
-        defaultValue: "/images/functions/default.png"
+    defaultValue: '/images/functions/default.png'
   },
   type: {
     type: Sequelize.STRING,
@@ -36,4 +36,4 @@ module.exports = sequelize.define('function', {
     allowNull: false,
     defaultValue: 0
   }
-});
+})

api/models/quotes.js

@@ -1,18 +1,18 @@
-const Sequelize = require('sequelize');
+const Sequelize = require('sequelize')
-const sequelize = require('../assets/utils/database');
+const sequelize = require('../assets/utils/database')
 
 module.exports = sequelize.define('quote', {
   quote: {
     type: Sequelize.STRING,
-        allowNull: false,
+    allowNull: false
   },
   author: {
     type: Sequelize.STRING,
-        allowNull: false,
+    allowNull: false
   },
   isValidated: {
     type: Sequelize.BOOLEAN,
     allowNull: false,
     defaultValue: 0
   }
-});
+})

api/models/short_links.js

@@ -1,13 +1,13 @@
-const Sequelize = require('sequelize');
+const Sequelize = require('sequelize')
-const sequelize = require('../assets/utils/database');
+const sequelize = require('../assets/utils/database')
 
 module.exports = sequelize.define('short_link', {
   url: {
     type: Sequelize.TEXT,
-        allowNull: false,
+    allowNull: false
   },
   shortcut: {
     type: Sequelize.TEXT,
-        allowNull: false,
+    allowNull: false
   }
-});
+})

api/models/tasks.js

@@ -1,14 +1,14 @@
-const Sequelize = require('sequelize');
+const Sequelize = require('sequelize')
-const sequelize = require('../assets/utils/database');
+const sequelize = require('../assets/utils/database')
 
 module.exports = sequelize.define('task', {
   task: {
     type: Sequelize.STRING,
-        allowNull: false,
+    allowNull: false
   },
   isCompleted: {
     type: Sequelize.BOOLEAN,
     allowNull: false,
     defaultValue: 0
   }
-});
+})

api/models/users.js

@@ -1,26 +1,26 @@
-const Sequelize = require('sequelize');
+const Sequelize = require('sequelize')
-const sequelize = require('../assets/utils/database');
+const sequelize = require('../assets/utils/database')
 
 module.exports = sequelize.define('user', {
   name: {
     type: Sequelize.STRING,
-        allowNull: false,
+    allowNull: false
   },
   email: {
     type: Sequelize.STRING,
-        allowNull: false,
+    allowNull: false
   },
   password: {
     type: Sequelize.STRING,
-        allowNull: false,
+    allowNull: false
   },
   biography: {
     type: Sequelize.TEXT,
-        defaultValue: ""
+    defaultValue: ''
   },
   logo: {
     type: Sequelize.STRING,
-        defaultValue: "/images/users/default.png"
+    defaultValue: '/images/users/default.png'
   },
   isConfirmed: {
     type: Sequelize.BOOLEAN,
@@ -42,4 +42,4 @@ module.exports = sequelize.define('user', {
     type: Sequelize.DATE,
     allowNull: true
   }
-});
+})

api/package.json

@@ -1,15 +1,12 @@
 {
   "name": "api",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Backend REST API for FunctionProject",
-  "main": "app.js",
   "scripts": {
     "start": "node app.js",
-    "dev": "nodemon app.js"
+    "dev": "nodemon app.js",
+    "format": "standard \"./**/*.js\" --fix | snazzy || exit 0"
   },
-  "keywords": [],
-  "author": "Divlo",
-  "license": "MIT",
   "dependencies": {
     "axios": "^0.19.2",
     "bcryptjs": "^2.4.3",
@@ -28,11 +25,13 @@
     "sequelize": "^5.21.5",
     "smart-request-balancer": "^2.1.1",
     "uuid": "^7.0.2",
-    "validator": "^13.0.0"
+    "validator": "^13.0.0",
+    "dotenv": "^8.2.0",
+    "morgan": "^1.9.1"
   },
   "devDependencies": {
-    "dotenv": "^8.2.0",
+    "nodemon": "^2.0.4",
-    "morgan": "^1.9.1",
+    "snazzy": "^8.0.0",
-    "nodemon": "^2.0.2"
+    "standard": "^14.3.4"
   }
 }

api/routes/admin.js

@@ -1,11 +1,11 @@
-const { Router }      = require('express');
+const { Router } = require('express')
-const fileUpload      = require('express-fileupload');
+const fileUpload = require('express-fileupload')
-const { body }        = require('express-validator');
+const { body } = require('express-validator')
-const adminController = require('../controllers/admin');
+const adminController = require('../controllers/admin')
-const Functions       = require('../models/functions');
+const Functions = require('../models/functions')
-const Categories      = require('../models/categories');
+const Categories = require('../models/categories')
 
-const AdminRouter = Router();
+const AdminRouter = Router()
 
 AdminRouter.route('/functions')
 
@@ -13,7 +13,8 @@ AdminRouter.route('/functions')
   .get(adminController.getFunctions)
 
   // Permet de créé une fonction
-    .post(fileUpload({ 
+  .post(
+    fileUpload({
       useTempFiles: true,
       safeFileNames: true,
       preserveExtension: Number,
@@ -24,83 +25,93 @@ AdminRouter.route('/functions')
       body('title')
         .not()
         .isEmpty()
-            .withMessage("La fonction doit avoir un titre.")
+        .withMessage('La fonction doit avoir un titre.')
         .isLength({ max: 100 })
-            .withMessage("Le titre est trop long.")
+        .withMessage('Le titre est trop long.')
-            .custom(((title) => {
+        .custom(title => {
           if (title === 'undefined') {
-                    return Promise.reject("La fonction doit avoir un titre.");
+            return Promise.reject(new Error('La fonction doit avoir un titre.'))
           }
-                return true;
+          return true
-            })),
+        }),
       body('slug')
         .not()
         .isEmpty()
-            .withMessage("La fonction doit avoir un slug.")
+        .withMessage('La fonction doit avoir un slug.')
         .isLength({ max: 100 })
-            .withMessage("Le slug est trop long.")
+        .withMessage('Le slug est trop long.')
-            .custom(((slug) => {
+        .custom(slug => {
           if (slug === 'undefined') {
-                    return Promise.reject("La fonction doit avoir un slug.");
+            return Promise.reject(new Error('La fonction doit avoir un slug.'))
           }
-                return true;
+          return true
-            }))
+        })
-            .custom((async (slug) => {
+        .custom(async slug => {
           try {
-                    const FunctionSlug = await Functions.findOne({ where: { slug } });
+            const FunctionSlug = await Functions.findOne({ where: { slug } })
             if (FunctionSlug) {
-                        return Promise.reject("Le slug existe déjà...");
+              return Promise.reject(new Error('Le slug existe déjà...'))
             }
           } catch (error) {
-                    console.log(error);
+            console.log(error)
           }
-                return true;
+          return true
-            })),
+        }),
       body('description')
         .not()
         .isEmpty()
-            .withMessage("La fonction doit avoir une description.")
+        .withMessage('La fonction doit avoir une description.')
         .isLength({ max: 255, min: 1 })
-            .withMessage("La description est trop longue.")
+        .withMessage('La description est trop longue.')
-            .custom(((description) => {
+        .custom(description => {
           if (description === 'undefined') {
-                    return Promise.reject("La fonction doit avoir une description.");
+            return Promise.reject(
+              new Error('La fonction doit avoir une description.')
+            )
           }
-                return true;
+          return true
-            })),
+        }),
       body('categorieId')
         .not()
         .isEmpty()
-            .withMessage("La fonction doit avoir une catégorie.")
+        .withMessage('La fonction doit avoir une catégorie.')
-            .custom(async (categorieId) => {
+        .custom(async categorieId => {
           try {
-                    const categorieFound = await Categories.findOne({ where: { id: parseInt(categorieId) } });
+            const categorieFound = await Categories.findOne({
+              where: { id: parseInt(categorieId) }
+            })
             if (!categorieFound) {
-                        return Promise.reject("La catégorie n'existe pas!");
+              return Promise.reject(new Error("La catégorie n'existe pas!"))
             }
           } catch (error) {
-                    console.log(error);
+            console.log(error)
           }
-                return true;
+          return true
         }),
-        body('type')
+      body('type').custom(type => {
-            .custom((type) => {
         if (!(type === 'article' || type === 'form' || type === 'page')) {
-                    return Promise.reject('Le type de la fonction peut être : article, form ou page.');
+          return Promise.reject(
+            new Error(
+              'Le type de la fonction peut être : article, form ou page.'
+            )
+          )
         }
-                return true;
+        return true
       })
-    ], adminController.postFunction);
+    ],
+    adminController.postFunction
+  )
 
 AdminRouter.route('/functions/:slug')
 
   // Récupère les informations d'une fonction
-    .get(adminController.getFunctionBySlug);
+  .get(adminController.getFunctionBySlug)
 
 AdminRouter.route('/functions/:id')
 
   // Modifie information basique d'une fonction
-    .put(fileUpload({ 
+  .put(
+    fileUpload({
       useTempFiles: true,
       safeFileNames: true,
       preserveExtension: Number,
@@ -111,78 +122,85 @@ AdminRouter.route('/functions/:id')
       body('title')
         .not()
         .isEmpty()
-            .withMessage("La fonction doit avoir un titre.")
+        .withMessage('La fonction doit avoir un titre.')
         .isLength({ max: 100 })
-            .withMessage("Le titre est trop long.")
+        .withMessage('Le titre est trop long.')
-            .custom(((title) => {
+        .custom(title => {
           if (title === 'undefined') {
-                    return Promise.reject("La fonction doit avoir un titre.");
+            return Promise.reject(new Error('La fonction doit avoir un titre.'))
           }
-                return true;
+          return true
-            })),
+        }),
       body('slug')
         .not()
         .isEmpty()
-            .withMessage("La fonction doit avoir un slug.")
+        .withMessage('La fonction doit avoir un slug.')
         .isLength({ max: 100 })
-            .withMessage("Le slug est trop long.")
+        .withMessage('Le slug est trop long.')
-            .custom(((slug) => {
+        .custom(slug => {
           if (slug === 'undefined') {
-                    return Promise.reject("La fonction doit avoir un slug.");
+            return Promise.reject(new Error('La fonction doit avoir un slug.'))
           }
-                return true;
+          return true
-            })),
+        }),
       body('description')
         .not()
         .isEmpty()
-            .withMessage("La fonction doit avoir une description.")
+        .withMessage('La fonction doit avoir une description.')
         .isLength({ max: 255, min: 1 })
-            .withMessage("La description est trop longue.")
+        .withMessage('La description est trop longue.')
-            .custom(((description) => {
+        .custom(description => {
           if (description === 'undefined') {
-                    return Promise.reject("La fonction doit avoir une description.");
+            return Promise.reject(
+              new Error('La fonction doit avoir une description.')
+            )
           }
-                return true;
+          return true
-            })),
+        }),
       body('categorieId')
         .not()
         .isEmpty()
-            .withMessage("La fonction doit avoir une catégorie.")
+        .withMessage('La fonction doit avoir une catégorie.')
-            .custom(async (categorieId) => {
+        .custom(async categorieId => {
           try {
-                    const categorieFound = await Categories.findOne({ where: { id: parseInt(categorieId) } });
+            const categorieFound = await Categories.findOne({
+              where: { id: parseInt(categorieId) }
+            })
             if (!categorieFound) {
-                        return Promise.reject("La catégorie n'existe pas!");
+              return Promise.reject(new Error("La catégorie n'existe pas!"))
             }
           } catch (error) {
-                    console.log(error);
+            console.log(error)
           }
-                return true;
+          return true
         }),
-        body('type')
+      body('type').custom(type => {
-            .custom((type) => {
         if (!(type === 'article' || type === 'form' || type === 'page')) {
-                    return Promise.reject('Le type de la fonction peut être : article, form ou page.');
+          return Promise.reject(
+            new Error(
+              'Le type de la fonction peut être : article, form ou page.'
+            )
+          )
         }
-                return true;
+        return true
       })
-    ], adminController.putFunction)
+    ],
+    adminController.putFunction
+  )
 
   // Supprime une fonction avec son id
-    .delete(adminController.deleteFunction);
+  .delete(adminController.deleteFunction)
 
 AdminRouter.route('/functions/article/:id')
-
+  .put(adminController.putFunctionArticle)
-    .put(adminController.putFunctionArticle);
 
 AdminRouter.route('/functions/form/:id')
-
+  .put(adminController.putFunctionForm)
-    .put(adminController.putFunctionForm);
 
 AdminRouter.route('/categories')
 
   // Crée une catégorie
-    .post(adminController.postCategory);
+  .post(adminController.postCategory)
 
 AdminRouter.route('/categories/:id')
 
@@ -190,16 +208,16 @@ AdminRouter.route('/categories/:id')
   .put(adminController.putCategory)
 
   // Supprime une catégorie avec son id
-    .delete(adminController.deleteCategory);
+  .delete(adminController.deleteCategory)
 
 AdminRouter.route('/quotes')
 
   // Récupère les citations pas encore validées
-    .get(adminController.getQuotes);
+  .get(adminController.getQuotes)
 
 AdminRouter.route('/quotes/:id')
 
   // Valide ou supprime une citation
-    .put(adminController.putQuote);
+  .put(adminController.putQuote)
 
-module.exports = AdminRouter;
+module.exports = AdminRouter

api/routes/categories.js

@@ -1,11 +1,11 @@
-const { Router }           = require('express');
+const { Router } = require('express')
-const categoriesController = require('../controllers/categories');
+const categoriesController = require('../controllers/categories')
 
-const CategoriesRouter = Router();
+const CategoriesRouter = Router()
 
 CategoriesRouter.route('/')
 
   // Récupère les catégories
-    .get(categoriesController.getCategories);
+  .get(categoriesController.getCategories)
 
-module.exports = CategoriesRouter;
+module.exports = CategoriesRouter

api/routes/comments.js

@@ -1,8 +1,8 @@
-const { Router }         = require('express');
+const { Router } = require('express')
-const commentsController = require('../controllers/comments');
+const commentsController = require('../controllers/comments')
-const isAuth             = require('../middlewares/isAuth');
+const isAuth = require('../middlewares/isAuth')
 
-const CommentsRouter = Router();
+const CommentsRouter = Router()
 
 CommentsRouter.route('/:commentId')
 
@@ -10,7 +10,7 @@ CommentsRouter.route('/:commentId')
   .put(isAuth, commentsController.putCommentsById)
 
   // Supprime un commentaire
-    .delete(isAuth, commentsController.deleteCommentById);
+  .delete(isAuth, commentsController.deleteCommentById)
 
 CommentsRouter.route('/:functionId')
 
@@ -18,6 +18,6 @@ CommentsRouter.route('/:functionId')
   .get(commentsController.getCommentsByFunctionId)
 
   // Permet à un utilisateur de poster un commentaire sur une fonction
-    .post(isAuth, commentsController.postCommentsByFunctionId);
+  .post(isAuth, commentsController.postCommentsByFunctionId)
 
-module.exports = CommentsRouter;
+module.exports = CommentsRouter

api/routes/favorites.js

@@ -1,8 +1,8 @@
-const { Router }          = require('express');
+const { Router } = require('express')
-const favoritesController = require('../controllers/favorites');
+const favoritesController = require('../controllers/favorites')
-const isAuth              = require('../middlewares/isAuth');
+const isAuth = require('../middlewares/isAuth')
 
-const FavoritesRouter = Router();
+const FavoritesRouter = Router()
 
 FavoritesRouter.route('/:functionId')
 
@@ -13,6 +13,6 @@ FavoritesRouter.route('/:functionId')
   .post(isAuth, favoritesController.postFavoriteByFunctionId)
 
   // Supprime une fonction des favoris d'un utilisateur
-    .delete(isAuth, favoritesController.deleteFavoriteByFunctionId);
+  .delete(isAuth, favoritesController.deleteFavoriteByFunctionId)
 
-module.exports = FavoritesRouter;
+module.exports = FavoritesRouter

api/routes/functions.js

@@ -1,12 +1,12 @@
-const { Router }          = require('express');
+const { Router } = require('express')
-const functionsController = require('../controllers/functions');
+const functionsController = require('../controllers/functions')
 
-const FunctionsRouter = Router();
+const FunctionsRouter = Router()
 
 FunctionsRouter.route('/')
 
   // Récupère les fonctions
-    .get(functionsController.getFunctions);
+  .get(functionsController.getFunctions)
 
 FunctionsRouter.route('/:slug')
 
@@ -14,6 +14,6 @@ FunctionsRouter.route('/:slug')
   .get(functionsController.getFunctionBySlug)
 
   // Exécute la fonction demandée en paramètre
-    .post(functionsController.executeFunctionBySlug);
+  .post(functionsController.executeFunctionBySlug)
 
-module.exports = FunctionsRouter;
+module.exports = FunctionsRouter

api/routes/links_shortener.js

@@ -0,0 +1,23 @@
+const { Router } = require('express')
+const linksShortenerController = require('../controllers/links_shortener')
+const isAuth = require('../middlewares/isAuth')
+
+const LinksShortenerRouter = Router()
+
+LinksShortenerRouter.route('/')
+
+  // Récupère les liens d'un utilisateur
+  .get(isAuth, linksShortenerController.getLinks)
+
+  // Ajouter un lien à raccourcir d'un utilisateur
+  .post(isAuth, linksShortenerController.postLink)
+
+LinksShortenerRouter.route('/:id')
+
+  // Permet de modifier le lien raccourci d'un utilisateur
+  .put(isAuth, linksShortenerController.putLink)
+
+  // Supprimer un lien d'un utilisateur
+  .delete(isAuth, linksShortenerController.deleteLink)
+
+module.exports = LinksShortenerRouter

api/routes/quotes.js

@@ -1,8 +1,8 @@
-const { Router }       = require('express');
+const { Router } = require('express')
-const quotesController = require('../controllers/quotes');
+const quotesController = require('../controllers/quotes')
-const isAuth           = require('../middlewares/isAuth');
+const isAuth = require('../middlewares/isAuth')
 
-const QuotesRouter = Router();
+const QuotesRouter = Router()
 
 QuotesRouter.route('/')
 
@@ -10,6 +10,6 @@ QuotesRouter.route('/')
   .get(quotesController.getQuotes)
 
   // Proposer une citation
-    .post(isAuth, quotesController.postQuote);
+  .post(isAuth, quotesController.postQuote)
 
-module.exports = QuotesRouter;
+module.exports = QuotesRouter

api/routes/tasks.js

@@ -1,8 +1,8 @@
-const { Router }      = require('express');
+const { Router } = require('express')
-const tasksController = require('../controllers/tasks');
+const tasksController = require('../controllers/tasks')
-const isAuth          = require('../middlewares/isAuth');
+const isAuth = require('../middlewares/isAuth')
 
-const TasksRouter = Router();
+const TasksRouter = Router()
 
 TasksRouter.route('/')
 
@@ -10,7 +10,7 @@ TasksRouter.route('/')
   .get(isAuth, tasksController.getTasks)
 
   // Poster une nouvelle tâche à faire
-    .post(isAuth, tasksController.postTask);
+  .post(isAuth, tasksController.postTask)
 
 TasksRouter.route('/:id')
 
@@ -18,6 +18,6 @@ TasksRouter.route('/:id')
   .put(isAuth, tasksController.putTask)
 
   // Supprimer une tâche à faire
-    .delete(isAuth, tasksController.deleteTask);
+  .delete(isAuth, tasksController.deleteTask)
 
-module.exports = TasksRouter;
+module.exports = TasksRouter

api/routes/users.js

@@ -1,12 +1,12 @@
-const { Router }         = require('express');
+const { Router } = require('express')
-const { body }           = require('express-validator');
+const { body } = require('express-validator')
-const fileUpload         = require('express-fileupload');
+const fileUpload = require('express-fileupload')
-const usersController    = require('../controllers/users');
+const usersController = require('../controllers/users')
-const { requiredFields } = require('../assets/config/errors');
+const { requiredFields } = require('../assets/config/errors')
-const Users              = require('../models/users');
+const Users = require('../models/users')
-const isAuth             = require('../middlewares/isAuth');
+const isAuth = require('../middlewares/isAuth')
 
-const UsersRouter = Router();
+const UsersRouter = Router()
 
 UsersRouter.route('/')
 
@@ -14,7 +14,8 @@ UsersRouter.route('/')
   .get(usersController.getUsers)
 
   // Permet de modifier son profil
-    .put(isAuth, 
+  .put(
+    isAuth,
     fileUpload({
       useTempFiles: true,
       safeFileNames: true,
@@ -25,49 +26,57 @@ UsersRouter.route('/')
     [
       body('email')
         .isEmail()
-            .withMessage("Veuillez rentré une adresse mail valide.")
+        .withMessage('Veuillez rentré une adresse mail valide.')
-            .custom((async (email) => {
+        .custom(async email => {
           try {
-                    const user = await Users.findOne({ where: { email } });
+            const user = await Users.findOne({ where: { email } })
             if (user && user.email !== email) {
-                        return Promise.reject("L'adresse email existe déjà...");
+              return Promise.reject(new Error("L'adresse email existe déjà..."))
             }
           } catch (error) {
-                    return console.log(error);
+            return console.log(error)
           }
-                return true;
+          return true
-            }))
+        })
         .normalizeEmail(),
       body('name')
         .trim()
         .not()
         .isEmpty()
-            .withMessage("Vous devez avoir un nom (ou pseudo).")
+        .withMessage('Vous devez avoir un nom (ou pseudo).')
         .isAlphanumeric()
-            .withMessage("Votre nom ne peut contenir que des lettres ou/et des nombres.")
+        .withMessage(
+          'Votre nom ne peut contenir que des lettres ou/et des nombres.'
+        )
         .isLength({ max: 30 })
-            .withMessage("Votre nom est trop long")
+        .withMessage('Votre nom est trop long')
-            .custom(async (name) => {
+        .custom(async name => {
           try {
-                    const user = await Users.findOne({ where: { name } });
+            const user = await Users.findOne({ where: { name } })
             if (user && user.name !== name) {
-                        return Promise.reject("Le nom existe déjà...");
+              return Promise.reject(new Error('Le nom existe déjà...'))
             }
           } catch (error) {
-                    console.log(error);
+            console.log(error)
           }
-                return true;
+          return true
         }),
       body('isPublicEmail')
         .isBoolean()
-            .withMessage("L'adresse email peut être public ou privé, rien d'autre."),
+        .withMessage(
+          "L'adresse email peut être public ou privé, rien d'autre."
+        ),
       body('biography')
         .trim()
         .escape()
-    ], usersController.putUser);
+    ],
+    usersController.putUser
+  )
 
 // Permet de se connecter
-UsersRouter.post('/login', [
+UsersRouter.post(
+  '/login',
+  [
     body('email')
       .not()
       .isEmpty()
@@ -76,70 +85,83 @@ UsersRouter.post('/login', [
       .not()
       .isEmpty()
       .withMessage(requiredFields.message)
-], usersController.login);
+  ],
+  usersController.login
+)
 
 // Récupère les informations public d'un profil
-UsersRouter.get('/:name', usersController.getUserInfo);
+UsersRouter.get('/:name', usersController.getUserInfo)
 
 // Permet de s'inscrire
-UsersRouter.post('/register', [
+UsersRouter.post(
+  '/register',
+  [
     body('email')
       .isEmail()
-        .withMessage("Veuillez rentré une adresse mail valide.")
+      .withMessage('Veuillez rentré une adresse mail valide.')
-        .custom((async (email) => {
+      .custom(async email => {
         try {
-                const user = await Users.findOne({ where: { email } });
+          const user = await Users.findOne({ where: { email } })
           if (user) {
-                    return Promise.reject("L'adresse email existe déjà...");
+            return Promise.reject(new Error("L'adresse email existe déjà..."))
           }
         } catch (error) {
-                return console.log(error);
+          return console.log(error)
         }
-            return true;
+        return true
-        }))
+      }),
-        .normalizeEmail(),
     body('password')
       .isLength({ min: 4 })
-        .withMessage("Votre mot de passe est trop court!"),
+      .withMessage('Votre mot de passe est trop court!'),
     body('name')
       .trim()
       .not()
       .isEmpty()
-        .withMessage("Vous devez avoir un nom (ou pseudo).")
+      .withMessage('Vous devez avoir un nom (ou pseudo).')
       .isAlphanumeric()
-        .withMessage("Votre nom ne peut contenir que des lettres ou/et des nombres.")
+      .withMessage(
+        'Votre nom ne peut contenir que des lettres ou/et des nombres.'
+      )
       .isLength({ max: 30 })
-        .withMessage("Votre nom est trop long")
+      .withMessage('Votre nom est trop long')
-        .custom(async (name) => {
+      .custom(async name => {
         try {
-                const user = await Users.findOne({ where: { name } });
+          const user = await Users.findOne({ where: { name } })
           if (user) {
-                    return Promise.reject("Le nom existe déjà...");
+            return Promise.reject(new Error('Le nom existe déjà...'))
           }
         } catch (error) {
-                console.log(error);
+          console.log(error)
         }
-            return true;
+        return true
       })
-], usersController.register);
+  ],
+  usersController.register
+)
 
 // Confirme l'inscription
-UsersRouter.get('/confirm-email/:tempToken', usersController.confirmEmail);
+UsersRouter.get('/confirm-email/:tempToken', usersController.confirmEmail)
 
 UsersRouter.route('/reset-password')
 
   // Demande une réinitialisation du mot de passe
-    .post([
+  .post(
+    [
       body('email')
         .isEmail()
-            .withMessage("Veuillez rentré une adresse mail valide.")
+        .withMessage('Veuillez rentré une adresse mail valide.')
-    ], usersController.resetPassword)
+    ],
+    usersController.resetPassword
+  )
 
   // Nouveau mot de passe
-    .put([
+  .put(
+    [
       body('password')
         .isLength({ min: 4 })
-            .withMessage("Votre mot de passe est trop court!")
+        .withMessage('Votre mot de passe est trop court!')
-    ], usersController.newPassword);
+    ],
+    usersController.newPassword
+  )
 
-module.exports = UsersRouter;
+module.exports = UsersRouter

s.divlo.fr/.env.example

@@ -0,0 +1,4 @@
+DB_HOST = ""
+DB_NAME = ""
+DB_USER = ""
+DB_PASS = ""

s.divlo.fr/.gitignore

@@ -0,0 +1,2 @@
+node_modules
+.env

s.divlo.fr/README.md

@@ -0,0 +1,3 @@
+# s.divlo.fr
+
+Site web qui permet de rediriger les utilisateurs vers leurs liens raccourcis sur [function.divlo.fr](https://function.divlo.fr/).

s.divlo.fr/app.js

@@ -0,0 +1,72 @@
+/* Modules */
+require('dotenv').config()
+const path = require('path')
+const express = require('express')
+const helmet = require('helmet')
+const morgan = require('morgan')
+const { redirectToHTTPS } = require('express-http-to-https')
+const mysql = require('mysql')
+
+/* Files Imports & Variables */
+const app = express()
+const database = mysql.createPool({
+  host: process.env.DB_HOST,
+  user: process.env.DB_USER,
+  password: process.env.DB_PASS,
+  database: process.env.DB_NAME,
+  port: process.env.DB_PORT
+})
+
+/* Middlewares */
+app.use(helmet())
+app.use(morgan('dev'))
+app.use(express.json())
+app.use(redirectToHTTPS([/localhost:(\d{4})/]))
+
+/* EJS Template Engines */
+app.set('view engine', 'ejs')
+app.set('views', path.join(__dirname, 'views'))
+
+/* Routes */
+app.use(express.static(path.join(__dirname, 'public')))
+
+app.get('/', (_req, res) => {
+  return res.render('index')
+})
+
+app.get('/:shortcut', (req, res, next) => {
+  const { shortcut } = req.params
+  if (shortcut == null) {
+    return res.redirect('/errors/404')
+  }
+  database.query(
+    'SELECT * FROM short_links WHERE shortcut = ?',
+    [shortcut],
+    (error, [result]) => {
+      if (error != null) {
+        return next(error)
+      }
+
+      if (result == null) {
+        return res.redirect('/error/404')
+      }
+
+      return res.redirect(result.url)
+    }
+  )
+})
+
+/* Errors */
+app.use((_req, res) => {
+  return res.status(404).render('errors')
+})
+app.use((error, _req, res) => {
+  console.log(error)
+  return res.status(500).render('errors')
+})
+
+/* Server */
+const PORT = process.env.PORT || 8000
+app.listen(PORT, () => {
+  console.log('\x1b[36m%s\x1b[0m', `Started on port ${PORT}.`)
+})

s.divlo.fr/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "short.divlo.fr",
+  "version": "1.0.0",
+  "description": "Link shortener for FunctionProject",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "nodemon app.js",
+    "format": "standard \"./**/*.js\" --fix | snazzy || exit 0"
+  },
+  "dependencies": {
+    "dotenv": "^8.2.0",
+    "ejs": "^3.1.3",
+    "express": "^4.17.1",
+    "express-http-to-https": "^1.1.4",
+    "helmet": "^4.0.0",
+    "morgan": "^1.10.0",
+    "mysql": "^2.18.1"
+  },
+  "devDependencies": {
+    "nodemon": "^2.0.4",
+    "snazzy": "^8.0.0",
+    "standard": "^14.3.4"
+  }
+}

s.divlo.fr/views/errors.ejs

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
+    <title>Short-links</title>
+    <link rel="icon" type="image/png" href="/images/error404.png" />
+  </head>
+  <body>
+    <style type="text/css">
+      * {
+        font-family: Arial;
+        color: #fff;
+        background-color: black;
+      }
+    </style>
+    <p>Adresse url non connue</p>
+  </body>
+</html>

s.divlo.fr/views/index.ejs

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
+    <title>Short-links</title>
+    <link rel="icon" type="image/png" href="/images/linkShortener.png" />
+  </head>
+  <body>
+    <style type="text/css">
+      * {
+        font-family: Arial;
+        color: #fff;
+        background-color: black;
+      }
+    </style>
+  </body>
+</html>

website/.env.example

@@ -0,0 +1 @@
+NEXT_PUBLIC_API_URL = "http://localhost:8080"

website/.gitignore

@@ -17,7 +17,8 @@
 
 # misc
 .DS_Store
-.env*
+.env
+.env.production
 
 # debug
 npm-debug.log*

website/components/CodeBlock.js

@@ -1,12 +0,0 @@
-import SyntaxHighlighter from "react-syntax-highlighter";
-import { atomOneDark as styles} from "react-syntax-highlighter/dist/cjs/styles/hljs";
-
-const CodeBlock = ({ language, value }) => {
-    return (
-        <SyntaxHighlighter language={language} style={styles}>
-            {value}
-        </SyntaxHighlighter>
-    );
-};
-
-export default CodeBlock;

website/components/CodeBlock.jsx

@@ -0,0 +1,12 @@
+import SyntaxHighlighter from 'react-syntax-highlighter'
+import { atomOneDark as styles } from 'react-syntax-highlighter/dist/cjs/styles/hljs'
+
+const CodeBlock = ({ language, value }) => {
+  return (
+    <SyntaxHighlighter language={language} style={styles}>
+      {value}
+    </SyntaxHighlighter>
+  )
+}
+
+export default CodeBlock

website/components/Footer/Footer.js

@@ -1,16 +0,0 @@
-import Link from 'next/link';
-import './Footer.css';
-
-export default function Footer() {
-    return (
-        <footer className="footer">
-            <p className="footer-text text-center">
-                <Link href={"/about"}>
-                    <a>FunctionProject</a>
-                </Link>
-                &nbsp;- Version 2.0 <br/>
-                <a href="https://divlo.fr/" target="_blank" rel="noopener noreferrer">Divlo</a> | Tous droits réservés
-            </p>
-        </footer>
-    );
-}

website/components/Footer/Footer.jsx

@@ -0,0 +1,19 @@
+import Link from 'next/link'
+import './Footer.css'
+
+export default function Footer () {
+  return (
+    <footer className='footer'>
+      <p className='footer-text text-center'>
+        <Link href='/about'>
+          <a>FunctionProject</a>
+        </Link>
+        &nbsp;- Version 2.1 <br />
+        <a href='https://divlo.fr/' target='_blank' rel='noopener noreferrer'>
+          Divlo
+        </a>{' '}
+        | Tous droits réservés
+      </p>
+    </footer>
+  )
+}

website/components/FunctionAdmin/AddEditFunction.js

@@ -1,129 +0,0 @@
-import { Fragment, useState, useEffect } from 'react';
-import htmlParser from 'html-react-parser';
-import Loader from '../../components/Loader';
-import useAPI from '../../hooks/useAPI';
-import api from '../../utils/api';
-import '../../public/css/pages/admin.css';
-
-const AddEditFunction = (props) => {
-
-    const [, categories]              = useAPI('/categories');
-    const [inputState, setInputState] = useState(props.defaultInputState);
-    const [message, setMessage]       = useState("");
-    const [isLoading, setIsLoading]   = useState(false);
-
-    useEffect(() => {
-        if (categories.length > 0 && !props.isEditing) {
-            handleChange({
-                target: {
-                    name: "categorieId",
-                    value: categories[0].id
-                }
-            });
-        }
-    }, [categories]);
-
-    const apiCallFunction = (formData) => {
-        if (props.isEditing) return api.put(`/admin/functions/${inputState.id}`, formData, { headers: { 'Authorization': props.user.token } });
-        return api.post('/admin/functions', formData, { headers: { 'Authorization': props.user.token } });
-    }
-
-    const handleChange = (event, isTypeCheck = false) => {
-        const inputStateNew = { ...inputState };
-        inputStateNew[event.target.name] = (event.target.files != undefined) ? event.target.files[0] : (isTypeCheck) ? event.target.checked : event.target.value;
-        setInputState(inputStateNew);
-    }
-
-    const handleSubmit = (event) => {
-        event.preventDefault();
-        setIsLoading(true);
-        const formData = new FormData();
-        formData.append('type', inputState.type);
-        formData.append('categorieId', inputState.categorieId);
-        formData.append('title', inputState.title);
-        formData.append('slug', inputState.slug);
-        formData.append('description', inputState.description);
-        formData.append('image', inputState.image);
-
-        if (props.isEditing) {
-            formData.append('isOnline', inputState.isOnline);
-        }
-
-        apiCallFunction(formData)
-            .then(() => {
-                setIsLoading(false);
-                window.location.reload(true);
-            })
-            .catch((error) => {
-                setMessage(`<p class="form-error"><b>Erreur:</b> ${error.response.data.message}</p>`);
-                setIsLoading(false);
-            });
-    }
-
-    return (
-        <Fragment>
-            <form onSubmit={handleSubmit}>
-                <div className="form-group">
-                    <label className="form-label" htmlFor="title">Titre :</label>
-                    <input value={inputState.title} onChange={handleChange} type="text" name="title" id="title" className="form-control" placeholder="(e.g : Nombre aléatoire)" />
-                </div>
-
-                <div className="form-group">
-                    <label className="form-label" htmlFor="slug">Slug :</label>
-                    <input value={inputState.slug} onChange={handleChange} type="text" name="slug" id="slug" className="form-control" placeholder="(e.g : randomNumber)" />
-                </div>
-
-                <div className="form-group">
-                    <label className="form-label" htmlFor="description">Description :</label>
-                    <textarea style={{ height: 'auto' }} value={inputState.description} onChange={handleChange} name="description" id="description" className="form-control" rows="5"></textarea>
-                </div>
-
-                <div className="form-group">
-                    <label className="form-label" htmlFor="type">Type :</label>
-                    <select onChange={handleChange} name="type" id="type" className="form-control" { ...(props.isEditing) && { value: inputState.type } }>
-                        <option value="form">Formulaire</option>
-                        <option value="article">Article</option>
-                        <option value="page">Page</option>
-                    </select>
-                </div>
-
-                <div className="form-group">
-                    <label className="form-label" htmlFor="categorieId">Catégorie :</label>
-                    <select onChange={handleChange} name="categorieId" id="categorieId" className="form-control" { ...(props.isEditing) && { value: inputState.categorieId } }>
-                        {categories.map((category) => (
-                            <option key={category.id} value={category.id} className="Admin__Modal-select-option" style={{ backgroundColor: category.color }}>{category.name}</option>
-                        ))}
-                    </select>
-                </div>
-
-                <div className="form-group">
-                    <label className="form-label" htmlFor="image">Image <em>(150x150 recommandé)</em> :</label>
-                    <br/>
-                    <input onChange={handleChange} accept="image/jpeg,image/jpg,image/png" type="file" name="image" id="image" />
-                </div>
-
-                {(props.isEditing) &&                 
-                    <div className="form-group custom-control custom-switch">
-                        <input onChange={(event) => handleChange(event, true)} type="checkbox" name="isOnline" checked={inputState.isOnline} className="custom-control-input" id="isOnline" />
-                        <label className="custom-control-label" htmlFor="isOnline">isOnline</label>
-                    </div>
-                }
-
-                <div className="form-group text-center">
-                    <button type="submit" className="btn btn-dark">Envoyer</button>
-                </div>
-            </form>
-
-            <div className="form-result text-center">
-                {
-                    (isLoading) ? 
-                        <Loader />
-                    :
-                        htmlParser(message)
-                }
-            </div>
-        </Fragment>
-    );
-}
-
-export default AddEditFunction;

website/components/FunctionAdmin/AddEditFunction.jsx

@@ -0,0 +1,208 @@
+import { useState, useEffect } from 'react'
+import htmlParser from 'html-react-parser'
+import Loader from '../Loader'
+import useAPI from '../../hooks/useAPI'
+import api from '../../utils/api'
+import '../../public/css/pages/admin.css'
+
+const AddEditFunction = props => {
+  const [, categories] = useAPI('/categories')
+  const [inputState, setInputState] = useState(props.defaultInputState)
+  const [message, setMessage] = useState('')
+  const [isLoading, setIsLoading] = useState(false)
+
+  useEffect(() => {
+    if (categories.length > 0 && !props.isEditing) {
+      handleChange({
+        target: {
+          name: 'categorieId',
+          value: categories[0].id
+        }
+      })
+    }
+  }, [categories])
+
+  const apiCallFunction = formData => {
+    if (props.isEditing) {
+      return api.put(`/admin/functions/${inputState.id}`, formData, {
+        headers: { Authorization: props.user.token }
+      })
+    }
+    return api.post('/admin/functions', formData, {
+      headers: { Authorization: props.user.token }
+    })
+  }
+
+  const handleChange = (event, isTypeCheck = false) => {
+    const inputStateNew = { ...inputState }
+    inputStateNew[event.target.name] =
+      event.target.files != null
+        ? event.target.files[0]
+        : isTypeCheck
+          ? event.target.checked
+          : event.target.value
+    setInputState(inputStateNew)
+  }
+
+  const handleSubmit = event => {
+    event.preventDefault()
+    setIsLoading(true)
+    const formData = new window.FormData()
+    formData.append('type', inputState.type)
+    formData.append('categorieId', inputState.categorieId)
+    formData.append('title', inputState.title)
+    formData.append('slug', inputState.slug)
+    formData.append('description', inputState.description)
+    formData.append('image', inputState.image)
+
+    if (props.isEditing) {
+      formData.append('isOnline', inputState.isOnline)
+    }
+
+    apiCallFunction(formData)
+      .then(() => {
+        setIsLoading(false)
+        window.location.reload(true)
+      })
+      .catch(error => {
+        setMessage(
+          `<p class="form-error"><b>Erreur:</b> ${error.response.data.message}</p>`
+        )
+        setIsLoading(false)
+      })
+  }
+
+  return (
+    <>
+      <form onSubmit={handleSubmit}>
+        <div className='form-group'>
+          <label className='form-label' htmlFor='title'>
+            Titre :
+          </label>
+          <input
+            value={inputState.title}
+            onChange={handleChange}
+            type='text'
+            name='title'
+            id='title'
+            className='form-control'
+            placeholder='(e.g : Nombre aléatoire)'
+          />
+        </div>
+
+        <div className='form-group'>
+          <label className='form-label' htmlFor='slug'>
+            Slug :
+          </label>
+          <input
+            value={inputState.slug}
+            onChange={handleChange}
+            type='text'
+            name='slug'
+            id='slug'
+            className='form-control'
+            placeholder='(e.g : randomNumber)'
+          />
+        </div>
+
+        <div className='form-group'>
+          <label className='form-label' htmlFor='description'>
+            Description :
+          </label>
+          <textarea
+            style={{ height: 'auto' }}
+            value={inputState.description}
+            onChange={handleChange}
+            name='description'
+            id='description'
+            className='form-control'
+            rows='5'
+          />
+        </div>
+
+        <div className='form-group'>
+          <label className='form-label' htmlFor='type'>
+            Type :
+          </label>
+          <select
+            onChange={handleChange}
+            name='type'
+            id='type'
+            className='form-control'
+            {...(props.isEditing && { value: inputState.type })}
+          >
+            <option value='form'>Formulaire</option>
+            <option value='article'>Article</option>
+            <option value='page'>Page</option>
+          </select>
+        </div>
+
+        <div className='form-group'>
+          <label className='form-label' htmlFor='categorieId'>
+            Catégorie :
+          </label>
+          <select
+            onChange={handleChange}
+            name='categorieId'
+            id='categorieId'
+            className='form-control'
+            {...(props.isEditing && { value: inputState.categorieId })}
+          >
+            {categories.map(category => (
+              <option
+                key={category.id}
+                value={category.id}
+                className='Admin__Modal-select-option'
+                style={{ backgroundColor: category.color }}
+              >
+                {category.name}
+              </option>
+            ))}
+          </select>
+        </div>
+
+        <div className='form-group'>
+          <label className='form-label' htmlFor='image'>
+            Image <em>(150x150 recommandé)</em> :
+          </label>
+          <br />
+          <input
+            onChange={handleChange}
+            accept='image/jpeg,image/jpg,image/png'
+            type='file'
+            name='image'
+            id='image'
+          />
+        </div>
+
+        {props.isEditing && (
+          <div className='form-group custom-control custom-switch'>
+            <input
+              onChange={event => handleChange(event, true)}
+              type='checkbox'
+              name='isOnline'
+              checked={inputState.isOnline}
+              className='custom-control-input'
+              id='isOnline'
+            />
+            <label className='custom-control-label' htmlFor='isOnline'>
+              isOnline
+            </label>
+          </div>
+        )}
+
+        <div className='form-group text-center'>
+          <button type='submit' className='btn btn-dark'>
+            Envoyer
+          </button>
+        </div>
+      </form>
+
+      <div className='form-result text-center'>
+        {isLoading ? <Loader /> : htmlParser(message)}
+      </div>
+    </>
+  )
+}
+
+export default AddEditFunction

website/components/FunctionAdmin/EditArticleFunction.js

@@ -1,46 +0,0 @@
-import { useState } from 'react';
-import dynamic from 'next/dynamic';
-import { complex } from '../../utils/sunEditorConfig';
-import api from '../../utils/api';
-import FunctionArticle from '../FunctionPage/FunctionArticle';
-import 'notyf/notyf.min.css';
-import '../../public/css/suneditor.min.css';
-
-const SunEditor = dynamic(
-    () => import('suneditor-react'),
-    { ssr: false }
-);
-
-const EditArticleFunction = (props) => {
-
-    const [htmlContent, setHtmlContent] = useState("");
-
-    const handleEditorChange = (content) => {
-        setHtmlContent(content);
-    }
-
-    const handleSave = async (content) => {
-        let Notyf;
-        if (typeof window != 'undefined') {
-            Notyf = require('notyf');
-        }
-        const notyf = new Notyf.Notyf({
-            duration: 5000
-        });
-        try {
-            await api.put(`/admin/functions/article/${props.functionInfo.id}`, { article: content }, { headers: { 'Authorization': props.user.token } });
-            notyf.success('Sauvegardé!');
-        } catch {
-            notyf.error('Erreur!');
-        }
-    }
-
-    return (
-        <div className="container-fluid">
-            <SunEditor setContents={props.functionInfo.article} lang="fr" onChange={handleEditorChange} setOptions={{ buttonList: complex, callBackSave: handleSave }} />
-            <FunctionArticle article={htmlContent} />
-        </div>
-    );
-}
-
-export default EditArticleFunction;

website/components/FunctionAdmin/EditArticleFunction.jsx

@@ -0,0 +1,51 @@
+import { useState } from 'react'
+import dynamic from 'next/dynamic'
+import { complex } from '../../utils/sunEditorConfig'
+import api from '../../utils/api'
+import FunctionArticle from '../FunctionPage/FunctionArticle'
+import 'notyf/notyf.min.css'
+import '../../public/css/suneditor.min.css'
+
+const SunEditor = dynamic(() => import('suneditor-react'), { ssr: false })
+
+const EditArticleFunction = props => {
+  const [htmlContent, setHtmlContent] = useState('')
+
+  const handleEditorChange = content => {
+    setHtmlContent(content)
+  }
+
+  const handleSave = async content => {
+    let Notyf
+    if (typeof window !== 'undefined') {
+      Notyf = require('notyf')
+    }
+    const notyf = new Notyf.Notyf({
+      duration: 5000
+    })
+    try {
+      await api.put(
+        `/admin/functions/article/${props.functionInfo.id}`,
+        { article: content },
+        { headers: { Authorization: props.user.token } }
+      )
+      notyf.success('Sauvegardé!')
+    } catch {
+      notyf.error('Erreur!')
+    }
+  }
+
+  return (
+    <div className='container-fluid'>
+      <SunEditor
+        setContents={props.functionInfo.article}
+        lang='fr'
+        onChange={handleEditorChange}
+        setOptions={{ buttonList: complex, callBackSave: handleSave }}
+      />
+      <FunctionArticle article={htmlContent} />
+    </div>
+  )
+}
+
+export default EditArticleFunction

website/components/FunctionAdmin/EditFormFunction.js

@@ -1,158 +0,0 @@
-import { useState, Fragment } from 'react';
-import api from '../../utils/api';
-import 'notyf/notyf.min.css';
-
-const EditFormFunction = (props) => {
-
-    const [inputsArray, setInputsArray] = useState(props.functionInfo.utilizationForm || []);
-
-    const addInput = () => {
-        const newInputsArray = [...inputsArray];
-        newInputsArray.push({ name: "", label: "", placeholder: "", type: "text" });
-        setInputsArray(newInputsArray);
-    }
-
-    const addOption = (event) => {
-        const newInputsArray = [...inputsArray];
-        const index          = event.target.id.split('-')[1];
-        const inputObject    = newInputsArray[index];
-        inputObject.options.push({ name: "", value: "" });
-        setInputsArray(newInputsArray);
-    }
-
-    const handleChangeOption = (inputIndex, optionIndex, event) => {
-        const newInputsArray = [...inputsArray];
-        const inputObject    = newInputsArray[inputIndex];
-        const optionObject   = inputObject.options[optionIndex];
-        optionObject[event.target.name] = event.target.value;
-        setInputsArray(newInputsArray);
-    }
-
-    const handleChangeInput = (event) => {
-        const       newInputsArray     = [...inputsArray];
-        const       index              = event.target.id.split('-')[1];
-        const       inputObject        = newInputsArray[index];
-        inputObject[event.target.name] = event.target.value;
-        if (event.target.value === "select") {
-            inputObject.options = [];
-        }
-        setInputsArray(newInputsArray);
-    }
-
-    const handleSubmit = async (event) => {
-        event.preventDefault();
-        let Notyf;
-        if (typeof window != 'undefined') {
-            Notyf = require('notyf');
-        }
-        const notyf = new Notyf.Notyf({
-            duration: 5000
-        });
-        try {
-            await api.put(`/admin/functions/form/${props.functionInfo.id}`, { form: inputsArray }, { headers: { 'Authorization': props.user.token } });
-            notyf.success('Sauvegardé!');
-        } catch (error) {
-            notyf.error('Erreur!');
-        }
-    }
-
-    const handleRemoveInput = (event) => {
-        const newInputsArray = [...inputsArray];
-        const index          = event.target.id.split('-')[1];
-        newInputsArray.splice(index, 1);
-        setInputsArray(newInputsArray);
-    }
-
-    const handleRemoveOption = (inputIndex, optionIndex) => {
-        const newInputsArray = [...inputsArray];
-        const inputObject    = newInputsArray[inputIndex];
-        const optionsArray   = inputObject.options;
-        optionsArray.splice(optionIndex, 1);
-        setInputsArray(newInputsArray);
-    }
-
-    return (
-        <div className="container-fluid">
-
-            <form onSubmit={handleSubmit}>
-
-                {(inputsArray.length > 0) &&                
-                    <div className="form-group text-center">
-                        <button type="submit" className="btn btn-dark">Sauvegarder</button>
-                    </div>
-                }
-
-                {inputsArray.map((input, index) => {
-                    return (
-                        <div key={index} className="form-group Admin__Input-group">
-
-                            <div className="text-center">
-                                <button type="button" onClick={handleRemoveInput} id={`remove-${index}`} className="btn btn-dark">Supprimer l'input</button>
-                            </div>
-
-                            <label className="form-label" htmlFor={`name-${index}`}>Nom de l'input :</label>
-                            <input value={input.name} onChange={handleChangeInput} type="text" name="name" id={`name-${index}`} className="form-control" placeholder="(e.g : cityName)" />
-                            <br/>
-
-                            <label className="form-label" htmlFor={`label-${index}`}>Label :</label>
-                            <input value={input.label} onChange={handleChangeInput} type="text" name="label" id={`label-${index}`} className="form-control" placeholder="(e.g : Entrez le nom d'une ville :)" />
-                            <br/>
-                            
-                            {(input.type !== "select") && 
-                                <Fragment>
-                                    <label className="form-label" htmlFor={`placeholder-${index}`}>Placeholder :</label>
-                                    <input value={input.placeholder} onChange={handleChangeInput} type="text" name="placeholder" id={`placeholder-${index}`} className="form-control" placeholder="(e.g : Paris, FR)" />
-                                    <br/>
-                                </Fragment>
-                            }
-
-                            <label className="form-label" htmlFor={`type-${index}`}>Type :</label>
-                            <select value={input.type} onChange={handleChangeInput} name="type" id={`type-${index}`} className="form-control">
-                                <option value="text">text</option>
-                                <option value="integer">Number integer</option>
-                                <option value="float">Number float</option>
-                                <option value="calendar">calendar</option>
-                                <option value="select">select</option>
-                            </select>
-
-                            {(input.type === "select") &&
-                                <div style={{ marginTop: '50px' }}>
-
-                                    <label className="form-label">Options :</label>
-
-                                    {input.options.map((option, optionIndex) => {
-                                        return (
-                                            <div key={optionIndex} style={{ margin: "0 0 30px 0" }} className="form-group Admin__Input-group">
-                                                <div className="text-center">
-                                                    <button type="button" onClick={() => handleRemoveOption(index, optionIndex)} className="btn btn-dark">Supprimer l'option</button>
-                                                </div>
-
-                                                <label className="form-label" htmlFor={`optionName-${optionIndex}-${index}`}>Nom de l'option</label>
-                                                <input onChange={(event) => handleChangeOption(index, optionIndex, event)} value={option.name} id={`optionName-${optionIndex}-${index}`} name="name" type="text"className="form-control" placeholder="Nom de l'option" />
-
-                                                <br />
-                                                <label className="form-label" htmlFor={`optionValue-${optionIndex}-${index}`}>Valeur de l'option</label>
-                                                <input onChange={(event) => handleChangeOption(index, optionIndex, event)} value={option.value} id={`optionValue-${optionIndex}-${index}`} name="value" type="text"className="form-control" placeholder="Valeur de l'option" />
-                                            </div>
-                                        );
-                                    })}
-
-                                    <div className="form-group text-center">
-                                        <button id={`optionAdd-${index}`} onClick={addOption} type="button" className="btn btn-dark">Ajouter une option</button>
-                                    </div>
-                                </div> 
-                            }
-                        </div>
-                    );
-                })}
-
-            </form>
-
-            <div style={{ marginBottom: '30px' }} className="form-group text-center">
-                <button type="button" onClick={addInput} className="btn btn-dark">Ajouter un input</button>
-            </div>
-        </div>
-    );
-}
-
-export default EditFormFunction;

website/components/FunctionAdmin/EditFormFunction.jsx

@@ -0,0 +1,256 @@
+import { useState } from 'react'
+import api from '../../utils/api'
+import 'notyf/notyf.min.css'
+
+const EditFormFunction = props => {
+  const [inputsArray, setInputsArray] = useState(
+    props.functionInfo.utilizationForm || []
+  )
+
+  const addInput = () => {
+    const newInputsArray = [...inputsArray]
+    newInputsArray.push({ name: '', label: '', placeholder: '', type: 'text' })
+    setInputsArray(newInputsArray)
+  }
+
+  const addOption = event => {
+    const newInputsArray = [...inputsArray]
+    const index = event.target.id.split('-')[1]
+    const inputObject = newInputsArray[index]
+    inputObject.options.push({ name: '', value: '' })
+    setInputsArray(newInputsArray)
+  }
+
+  const handleChangeOption = (inputIndex, optionIndex, event) => {
+    const newInputsArray = [...inputsArray]
+    const inputObject = newInputsArray[inputIndex]
+    const optionObject = inputObject.options[optionIndex]
+    optionObject[event.target.name] = event.target.value
+    setInputsArray(newInputsArray)
+  }
+
+  const handleChangeInput = event => {
+    const newInputsArray = [...inputsArray]
+    const index = event.target.id.split('-')[1]
+    const inputObject = newInputsArray[index]
+    inputObject[event.target.name] = event.target.value
+    if (event.target.value === 'select') {
+      inputObject.options = []
+    }
+    setInputsArray(newInputsArray)
+  }
+
+  const handleSubmit = async event => {
+    event.preventDefault()
+    let Notyf
+    if (typeof window !== 'undefined') {
+      Notyf = require('notyf')
+    }
+    const notyf = new Notyf.Notyf({
+      duration: 5000
+    })
+    try {
+      await api.put(
+        `/admin/functions/form/${props.functionInfo.id}`,
+        { form: inputsArray },
+        { headers: { Authorization: props.user.token } }
+      )
+      notyf.success('Sauvegardé!')
+    } catch (error) {
+      notyf.error('Erreur!')
+    }
+  }
+
+  const handleRemoveInput = event => {
+    const newInputsArray = [...inputsArray]
+    const index = event.target.id.split('-')[1]
+    newInputsArray.splice(index, 1)
+    setInputsArray(newInputsArray)
+  }
+
+  const handleRemoveOption = (inputIndex, optionIndex) => {
+    const newInputsArray = [...inputsArray]
+    const inputObject = newInputsArray[inputIndex]
+    const optionsArray = inputObject.options
+    optionsArray.splice(optionIndex, 1)
+    setInputsArray(newInputsArray)
+  }
+
+  return (
+    <div className='container-fluid'>
+      <form onSubmit={handleSubmit}>
+        {inputsArray.length > 0 && (
+          <div className='form-group text-center'>
+            <button type='submit' className='btn btn-dark'>
+              Sauvegarder
+            </button>
+          </div>
+        )}
+
+        {inputsArray.map((input, index) => {
+          return (
+            <div key={index} className='form-group Admin__Input-group'>
+              <div className='text-center'>
+                <button
+                  type='button'
+                  onClick={handleRemoveInput}
+                  id={`remove-${index}`}
+                  className='btn btn-dark'
+                >
+                  Supprimer l'input
+                </button>
+              </div>
+
+              <label className='form-label' htmlFor={`name-${index}`}>
+                Nom de l'input :
+              </label>
+              <input
+                value={input.name}
+                onChange={handleChangeInput}
+                type='text'
+                name='name'
+                id={`name-${index}`}
+                className='form-control'
+                placeholder='(e.g : cityName)'
+              />
+              <br />
+
+              <label className='form-label' htmlFor={`label-${index}`}>
+                Label :
+              </label>
+              <input
+                value={input.label}
+                onChange={handleChangeInput}
+                type='text'
+                name='label'
+                id={`label-${index}`}
+                className='form-control'
+                placeholder="(e.g : Entrez le nom d'une ville :)"
+              />
+              <br />
+
+              {input.type !== 'select' && (
+                <>
+                  <label
+                    className='form-label'
+                    htmlFor={`placeholder-${index}`}
+                  >
+                    Placeholder :
+                  </label>
+                  <input
+                    value={input.placeholder}
+                    onChange={handleChangeInput}
+                    type='text'
+                    name='placeholder'
+                    id={`placeholder-${index}`}
+                    className='form-control'
+                    placeholder='(e.g : Paris, FR)'
+                  />
+                  <br />
+                </>
+              )}
+
+              <label className='form-label' htmlFor={`type-${index}`}>
+                Type :
+              </label>
+              <select
+                value={input.type}
+                onChange={handleChangeInput}
+                name='type'
+                id={`type-${index}`}
+                className='form-control'
+              >
+                <option value='text'>text</option>
+                <option value='integer'>Number integer</option>
+                <option value='float'>Number float</option>
+                <option value='calendar'>calendar</option>
+                <option value='select'>select</option>
+              </select>
+
+              {input.type === 'select' && (
+                <div style={{ marginTop: '50px' }}>
+                  <label className='form-label'>Options :</label>
+
+                  {input.options.map((option, optionIndex) => {
+                    return (
+                      <div
+                        key={optionIndex}
+                        style={{ margin: '0 0 30px 0' }}
+                        className='form-group Admin__Input-group'
+                      >
+                        <div className='text-center'>
+                          <button
+                            type='button'
+                            onClick={() =>
+                              handleRemoveOption(index, optionIndex)}
+                            className='btn btn-dark'
+                          >
+                            Supprimer l'option
+                          </button>
+                        </div>
+
+                        <label
+                          className='form-label'
+                          htmlFor={`optionName-${optionIndex}-${index}`}
+                        >
+                          Nom de l'option
+                        </label>
+                        <input
+                          onChange={event =>
+                            handleChangeOption(index, optionIndex, event)}
+                          value={option.name}
+                          id={`optionName-${optionIndex}-${index}`}
+                          name='name'
+                          type='text'
+                          className='form-control'
+                          placeholder="Nom de l'option"
+                        />
+
+                        <br />
+                        <label
+                          className='form-label'
+                          htmlFor={`optionValue-${optionIndex}-${index}`}
+                        >
+                          Valeur de l'option
+                        </label>
+                        <input
+                          onChange={event =>
+                            handleChangeOption(index, optionIndex, event)}
+                          value={option.value}
+                          id={`optionValue-${optionIndex}-${index}`}
+                          name='value'
+                          type='text'
+                          className='form-control'
+                          placeholder="Valeur de l'option"
+                        />
+                      </div>
+                    )
+                  })}
+
+                  <div className='form-group text-center'>
+                    <button
+                      id={`optionAdd-${index}`}
+                      onClick={addOption}
+                      type='button'
+                      className='btn btn-dark'
+                    >
+                      Ajouter une option
+                    </button>
+                  </div>
+                </div>
+              )}
+            </div>
+          )
+        })}
+      </form>
+
+      <div style={{ marginBottom: '30px' }} className='form-group text-center'>
+        <button type='button' onClick={addInput} className='btn btn-dark'>
+          Ajouter un input
+        </button>
+      </div>
+    </div>
+  )
+}
+
+export default EditFormFunction

website/components/FunctionCard/FunctionCard.css

@@ -4,12 +4,14 @@
   position: relative;
   flex-direction: column;
   word-wrap: break-word;
-    box-shadow: 0px 0px 6px 6px rgba(0, 0, 0, .25);
+  box-shadow: 0px 0px 6px 6px rgba(0, 0, 0, 0.25);
   border: 1px solid black;
   border-radius: 1rem;
   margin: 0 0 50px 0;
   cursor: pointer;
-    transition: all .3s;
+  transition: all 0.3s;
+  color: var(--text-color);
+  text-decoration: none !important;
 }
 .FunctionCard__container {
   height: 100%;

website/components/FunctionCard/FunctionCard.js

@@ -1,58 +0,0 @@
-import Link from 'next/link';
-import { useState, forwardRef } from 'react';
-import date from 'date-and-time';
-import Loader from '../Loader';
-import { API_URL } from '../../utils/config/config';
-import './FunctionCard.css';
-
-const FunctionCard = forwardRef((props, ref) => {
-
-    const [isLoading, setIsLoading] = useState(true);
-
-    const handleLoad = () => {
-        setIsLoading(false);
-    }
-
-    const handleError = (event) => {
-        event.target.src = API_URL + "/images/functions/default.png";
-    }
-
-    const isFormOrArticle = (props.type === 'form' || props.type === 'article');
-
-    return (
-        <Link 
-            { 
-                ...(props.isAdmin) ? 
-                {
-                    href: "/admin/[slug]",
-                    as: `/admin/${props.slug}`
-                } 
-                    : 
-                {
-                    href: (isFormOrArticle) ? "/functions/[slug]" : `/functions/${props.slug}`,
-                    as: `/functions/${props.slug}`
-                }
-            }
-        >
-            {/* FunctionCard a une hauteur pendant chargement */}
-            <div ref={ref} style={isLoading ? { height: "360px", justifyContent: "center" } : null} className={"FunctionCard col-sm-24 col-md-10 col-xl-7"}>
-
-                {isLoading && <Loader width="125px" height="125px" />} 
-
-                <div className={`FunctionCard__container ${isLoading ? "d-none" : ""}`}>
-                    <div className="FunctionCard__top">
-                        <img onLoad={handleLoad} onError={handleError} className="FunctionCard__image" alt={props.title} src={API_URL + props.image} />
-                        <h2 className="FunctionCard__title">{props.title}</h2>
-                        <p className="FunctionCard__description text-center">{props.description}</p>
-                    </div>
-                    <div className="FunctionCard__info">
-                        <p className="FunctionCard__category" style={{ backgroundColor: props.categorie.color }}>{props.categorie.name}</p>
-                        <p className="FunctionCard__publication-date">{date.format(new Date(props.createdAt), 'DD/MM/YYYY', true)}</p>
-                    </div>
-                </div>
-            </div>
-        </Link>
-    );
-}); 
-
-export default FunctionCard;

website/components/FunctionCard/FunctionCard.jsx

@@ -0,0 +1,80 @@
+import Link from 'next/link'
+import { useState, forwardRef, memo } from 'react'
+import date from 'date-and-time'
+import Loader from '../Loader'
+import { API_URL } from '../../utils/api'
+import './FunctionCard.css'
+
+const FunctionCard = memo(
+  forwardRef((props, ref) => {
+    const [isLoading, setIsLoading] = useState(true)
+
+    const handleLoad = () => {
+      setIsLoading(false)
+    }
+
+    const handleError = event => {
+      event.target.src = API_URL + '/images/functions/default.png'
+    }
+
+    const isFormOrArticle = props.type === 'form' || props.type === 'article'
+
+    return (
+      <Link
+        {...(props.isAdmin
+          ? {
+            href: '/admin/[slug]',
+            as: `/admin/${props.slug}`
+          }
+          : {
+            href: isFormOrArticle
+              ? '/functions/[slug]'
+              : `/functions/${props.slug}`,
+            as: `/functions/${props.slug}`
+          })}
+      >
+        {/* FunctionCard a une hauteur pendant chargement */}
+        <a
+          ref={ref}
+          style={
+            isLoading ? { height: '360px', justifyContent: 'center' } : null
+          }
+          className='FunctionCard col-sm-24 col-md-10 col-xl-7'
+        >
+          {isLoading && <Loader width='125px' height='125px' />}
+
+          <div
+            className={`FunctionCard__container ${isLoading ? 'd-none' : ''}`}
+          >
+            <div className='FunctionCard__top'>
+              <img
+                onLoad={handleLoad}
+                onError={handleError}
+                className='FunctionCard__image'
+                alt={props.title}
+                src={API_URL + props.image}
+              />
+              <h2 className='FunctionCard__title'>{props.title}</h2>
+              <p className='FunctionCard__description text-center'>
+                {props.description}
+              </p>
+            </div>
+            <div className='FunctionCard__info'>
+              <p
+                className='FunctionCard__category'
+                style={{ backgroundColor: props.categorie.color }}
+              >
+                {props.categorie.name}
+              </p>
+              <p className='FunctionCard__publication-date'>
+                {date.format(new Date(props.createdAt), 'DD/MM/YYYY', true)}
+              </p>
+            </div>
+          </div>
+        </a>
+      </Link>
+    )
+  })
+)
+
+export default FunctionCard

website/components/FunctionPage/CommentCard/CommentCard.css

@@ -2,9 +2,9 @@
   display: flex;
   flex-direction: column;
   word-wrap: break-word;
-    box-shadow: 0px 0px 6px 6px rgba(0, 0, 0, .25);
+  box-shadow: 0px 0px 6px 6px rgba(0, 0, 0, 0.25);
   border: 1px solid black;
-    border-radius: .7em;
+  border-radius: 0.7em;
   margin: 15px 0 15px 0;
 }
 .CommentCard__container {

website/components/FunctionPage/CommentCard/CommentCard.js

@@ -1,108 +0,0 @@
-import Link from 'next/link';
-import { useEffect, useState, forwardRef, useContext, Fragment } from 'react';
-import date from 'date-and-time';
-import htmlParser from 'html-react-parser';
-import { UserContext } from '../../../contexts/UserContext';
-import { API_URL } from '../../../utils/config/config';
-import ReactMarkdown  from 'react-markdown';
-import CodeBlock from "../../CodeBlock";
-import api from '../../../utils/api';
-import './CommentCard.css';
-
-const CommentCard = forwardRef((props, ref) => {
-
-    const { isAuth, user }          = useContext(UserContext);
-    const [isEditing, setEditing]   = useState(false);
-    const [editInput, setEditInput] = useState("");
-    const [message, setMessage]     = useState("");
-
-    useEffect(() => {
-        setEditInput(props.message);
-    }, []);
-
-    const deleteCommentById = async () => {
-        props.manageComment.setLoadingComments(true);
-        if (isAuth && user.token != undefined) {
-            try {
-                await api.delete(`/comments/${props.id}`, { headers: { 'Authorization': user.token } });
-                const newCommentsData = { ...props.manageComment.commentsData };
-                const commentIndex    = newCommentsData.rows.findIndex((value) => value.id === props.id);
-                newCommentsData.rows.splice(commentIndex, 1);
-                props.manageComment.setCommentsData({ hasMore: props.manageComment.commentsData.hasMore, rows: newCommentsData.rows });
-            } catch {}
-        }
-        props.manageComment.setLoadingComments(false);
-    }
-
-    const handleChange = (event) => {
-        setEditInput(event.target.value);
-    }
-
-    const handleSubmit = (event) => {
-        event.preventDefault();
-        api.put(`/comments/${props.id}`, { message: editInput }, { headers: { 'Authorization': user.token } })
-            .then((_response) => {
-                setEditing(false);
-            })
-            .catch((error) => {
-                setMessage(`<p class="form-error"><b>Erreur:</b> ${error.response.data.message}</p>`);
-            });
-    }
-
-    const editComment = () => {
-        setEditing(true);
-        setMessage("");
-    }
-
-    return (
-        <div ref={ref} className="CommentCard col-24">
-            <div className="CommentCard__container">
-                <div className="row">
-                    <Link href={"/users/[name]"} as={`/users/${props.user.name}`}>
-                        <img className="CommentCard__user-logo" src={API_URL + props.user.logo} alt={props.user.name} />    
-                    </Link>
-                    <span className="CommentCard__message-info">
-                        <Link href={"/users/[name]"} as={`/users/${props.user.name}`}>
-                            <a>{props.user.name}</a>
-                        </Link> 
-                        &nbsp;- {date.format(new Date(props.createdAt), 'DD/MM/YYYY à HH:mm', true)} 
-                    </span>
-                </div>
-                <div className="row">
-                    <div className="col-24">
-                        {
-                            (!isEditing) ?
-                                <Fragment>
-                                    <div className="CommentCard__message">
-                                        <ReactMarkdown source={editInput} renderers={{ code: CodeBlock }} />
-                                    </div>
-                                    {(isAuth && user.name === props.user.name) && 
-                                        <p style={{ fontSize: '15px', margin: '15px 0 0 0', fontStyle: 'italic' }}>
-                                            <a onClick={deleteCommentById} href="#">supprimer</a>
-                                            &nbsp;-&nbsp;
-                                            <a style={{ cursor: 'pointer' }} onClick={editComment}>modifier</a>
-                                        </p>
-                                    }
-                                </Fragment>
-                            : 
-                                <form onSubmit={handleSubmit}>
-                                    <div className="form-group FunctionComments__post-group">
-                                        <label className="form-label" htmlFor="commentEdit">Modifier le commentaire :</label>   
-                                        <textarea style={{ height: 'auto' }} value={editInput} onChange={handleChange} name="commentEdit" id="commentEdit" className="form-control" rows="5" placeholder="Idée d'amélioration, avis, remarque, partage d'expérience personnel, ... (Markdown autorisé)"></textarea>
-                                    </div>
-                                    <div className="form-group" style={{ marginTop: '0.7em' }}>
-                                        <button type="submit" className="btn btn-dark">Envoyer</button>
-                                    </div>
-                                    <div className="text-center">
-                                        {htmlParser(message)}
-                                    </div>
-                                </form>
-                        }
-                    </div>
-                </div>
-            </div>
-        </div>
-    );
-});
-
-export default CommentCard;

website/components/FunctionPage/CommentCard/CommentCard.jsx

@@ -0,0 +1,148 @@
+import Link from 'next/link'
+import { useEffect, useState, forwardRef, useContext } from 'react'
+import date from 'date-and-time'
+import htmlParser from 'html-react-parser'
+import { UserContext } from '../../../contexts/UserContext'
+import ReactMarkdown from 'react-markdown'
+import CodeBlock from '../../CodeBlock'
+import api, { API_URL } from '../../../utils/api'
+import './CommentCard.css'
+
+const CommentCard = forwardRef((props, ref) => {
+  const { isAuth, user } = useContext(UserContext)
+  const [isEditing, setEditing] = useState(false)
+  const [editInput, setEditInput] = useState('')
+  const [message, setMessage] = useState('')
+
+  useEffect(() => {
+    setEditInput(props.message)
+  }, [])
+
+  const deleteCommentById = async () => {
+    props.manageComment.setLoadingComments(true)
+    if (isAuth && user.token != null) {
+      try {
+        await api.delete(`/comments/${props.id}`, {
+          headers: { Authorization: user.token }
+        })
+        const newCommentsData = { ...props.manageComment.commentsData }
+        const commentIndex = newCommentsData.rows.findIndex(
+          value => value.id === props.id
+        )
+        newCommentsData.rows.splice(commentIndex, 1)
+        props.manageComment.setCommentsData({
+          hasMore: props.manageComment.commentsData.hasMore,
+          rows: newCommentsData.rows
+        })
+      } catch {}
+    }
+    props.manageComment.setLoadingComments(false)
+  }
+
+  const handleChange = event => {
+    setEditInput(event.target.value)
+  }
+
+  const handleSubmit = event => {
+    event.preventDefault()
+    api
+      .put(
+        `/comments/${props.id}`,
+        { message: editInput },
+        { headers: { Authorization: user.token } }
+      )
+      .then(_response => {
+        setEditing(false)
+      })
+      .catch(error => {
+        setMessage(
+          `<p class="form-error"><b>Erreur:</b> ${error.response.data.message}</p>`
+        )
+      })
+  }
+
+  const editComment = () => {
+    setEditing(true)
+    setMessage('')
+  }
+
+  return (
+    <div ref={ref} className='CommentCard col-24'>
+      <div className='CommentCard__container'>
+        <div className='row'>
+          <Link href='/users/[name]' as={`/users/${props.user.name}`}>
+            <img
+              className='CommentCard__user-logo'
+              src={API_URL + props.user.logo}
+              alt={props.user.name}
+            />
+          </Link>
+          <span className='CommentCard__message-info'>
+            <Link href='/users/[name]' as={`/users/${props.user.name}`}>
+              <a>{props.user.name}</a>
+            </Link>
+            &nbsp;-{' '}
+            {date.format(new Date(props.createdAt), 'DD/MM/YYYY à HH:mm', true)}
+          </span>
+        </div>
+        <div className='row'>
+          <div className='col-24'>
+            {!isEditing ? (
+              <>
+                <div className='CommentCard__message'>
+                  <ReactMarkdown
+                    source={editInput}
+                    renderers={{ code: CodeBlock }}
+                  />
+                </div>
+                {isAuth && user.name === props.user.name && (
+                  <p
+                    style={{
+                      fontSize: '15px',
+                      margin: '15px 0 0 0',
+                      fontStyle: 'italic'
+                    }}
+                  >
+                    <a onClick={deleteCommentById} href='#'>
+                      supprimer
+                    </a>
+                    &nbsp;-&nbsp;
+                    <a style={{ cursor: 'pointer' }} onClick={editComment}>
+                      modifier
+                    </a>
+                  </p>
+                )}
+              </>
+            ) : (
+              <form onSubmit={handleSubmit}>
+                <div className='form-group FunctionComments__post-group'>
+                  <label className='form-label' htmlFor='commentEdit'>
+                    Modifier le commentaire :
+                  </label>
+                  <textarea
+                    style={{ height: 'auto' }}
+                    value={editInput}
+                    onChange={handleChange}
+                    name='commentEdit'
+                    id='commentEdit'
+                    className='form-control'
+                    rows='5'
+                    placeholder="Idée d'amélioration, avis, remarque, partage d'expérience personnel, ... (Markdown autorisé)"
+                  />
+                </div>
+                <div className='form-group' style={{ marginTop: '0.7em' }}>
+                  <button type='submit' className='btn btn-dark'>
+                    Envoyer
+                  </button>
+                </div>
+                <div className='text-center'>{htmlParser(message)}</div>
+              </form>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+})
+
+export default CommentCard

website/components/FunctionPage/FunctionArticle.js

@@ -1,11 +0,0 @@
-import htmlParser from 'html-react-parser';
-
-const FunctionArticle = ({ article }) => {
-    return (
-        <div style={{ marginBottom: '50px' }} className="container-fluid">
-            {(article != undefined) ? htmlParser(article) : <p className="text-center">L'article n'est pas encore disponible.</p>}
-        </div>
-    );
-}
-
-export default FunctionArticle;

website/components/FunctionPage/FunctionArticle.jsx

@@ -0,0 +1,15 @@
+import htmlParser from 'html-react-parser'
+
+const FunctionArticle = ({ article }) => {
+  return (
+    <div style={{ marginBottom: '50px' }} className='container-fluid'>
+      {article != null ? (
+        htmlParser(article)
+      ) : (
+        <p className='text-center'>L'article n'est pas encore disponible.</p>
+      )}
+    </div>
+  )
+}
+
+export default FunctionArticle

website/components/FunctionPage/FunctionComments/FunctionComments.js

@@ -1,115 +0,0 @@
-import { Fragment, useState, useEffect, useContext, useRef, useCallback } from 'react';
-import Link from 'next/link';
-import { UserContext } from '../../../contexts/UserContext';
-import CommentCard from '../CommentCard/CommentCard';
-import Loader from '../../Loader';
-import api from '../../../utils/api';
-import './FunctionComments.css';
-
-const FunctionComments = ({ functionId }) => {
-
-    // State pour poster un commentaire
-    const { isAuth, user }                = useContext(UserContext);
-    const [inputState, setInputState]     = useState({});
-
-    // State pour afficher les commentaires
-    const [commentsData, setCommentsData]         = useState({ hasMore: true, rows: [] });
-    const [isLoadingComments, setLoadingComments] = useState(true);
-    const [pageComments, setPageComments]         = useState(1);
-
-    // Récupère les commentaires si la page change
-    useEffect(() => {
-        getCommentsData().then((data) => setCommentsData({ 
-            hasMore: data.hasMore, 
-            rows: [...commentsData.rows, ...data.rows] 
-        }));
-    }, [pageComments]);
-
-    // Permet la pagination au scroll
-    const observer = useRef();
-    const lastCommentCardRef = useCallback((node) => {
-        if (isLoadingComments) return;
-        if (observer.current) observer.current.disconnect();
-        observer.current = new IntersectionObserver((entries) => {
-            if (entries[0].isIntersecting && commentsData.hasMore) {
-                setPageComments(pageComments + 1);
-            }
-        }, { threshold: 1 });
-        if (node) observer.current.observe(node);
-    }, [isLoadingComments, commentsData.hasMore]);
-
-    const getCommentsData = () => {
-        setLoadingComments(true);
-        return new Promise(async (next) => {
-            const result = await api.get(`/comments/${functionId}/?page=${pageComments}&limit=10`);
-            setLoadingComments(false);
-            next(result.data);
-        });
-    }
-
-    const handleChange = (event) => {
-        const inputStateNew = { ...inputState };
-        inputStateNew[event.target.name] = event.target.value;
-        setInputState(inputStateNew);
-    }
-
-    const handleSubmit = async (event) => {
-        setLoadingComments(true);
-        event.preventDefault();
-        const token = user.token;
-        if (isAuth && token != undefined && inputState.commentPost != undefined) {
-            try {
-                const response = await api.post(`/comments/${functionId}`, { message: inputState.commentPost }, { headers: { 'Authorization': token } });
-                const comment = { ...response.data, user: { name: user.name, logo: user.logo } };
-                setCommentsData({ hasMore: commentsData.hasMore, rows: [comment, ...commentsData.rows] });
-                setInputState({ commentPost: "" });
-            } catch { }
-        }
-        setLoadingComments(false);
-    }
-
-    return (
-        <Fragment>
-            <div className="FunctionComments__post container-fluid">
-                <div className="row FunctionComments__row">
-                    <div className="col-24">
-                        {
-                            (isAuth) ?
-                                <form onSubmit={handleSubmit}>
-                                    <div className="form-group FunctionComments__post-group">
-                                        <label className="form-label" htmlFor="commentPost">Ajouter un commentaire :</label>   
-                                        <textarea className="FunctionComments__textarea form-control" value={inputState.commentPost} onChange={handleChange} name="commentPost" id="commentPost" placeholder="Idée d'amélioration, avis, remarque, partage d'expérience personnel, ... (Markdown autorisé)"></textarea>
-                                    </div>
-                                    <div className="form-group" style={{ marginTop: '0.7em' }}>
-                                        <button type="submit" className="btn btn-dark">Envoyer</button>
-                                    </div>
-                                </form>
-                            :
-                                <p className="text-center">
-                                    Vous devez être <Link href={'/users/login'}><a>connecté</a></Link> pour poster un commentaire.
-                                </p>
-                        }
-                    </div>
-                </div>
-            </div>
-            <div className="container-fluid">
-                {isLoadingComments && 
-                    <div className="row justify-content-center">
-                        <Loader />
-                    </div>
-                }
-                <div className="row justify-content-center">
-                    {commentsData.rows.map((comment, index) => {
-                        // Si c'est le dernier élément
-                        if (commentsData.rows.length === index + 1) {
-                            return <CommentCard key={comment.id} ref={lastCommentCardRef} { ...comment } manageComment={{ setCommentsData, commentsData, setLoadingComments }} />;
-                        }
-                        return <CommentCard key={comment.id} { ...comment } manageComment={{ setCommentsData, commentsData, setLoadingComments }} />;
-                    })}
-                </div>
-            </div>
-        </Fragment>
-    );
-}
-
-export default FunctionComments;

website/components/FunctionPage/FunctionComments/FunctionComments.jsx

@@ -0,0 +1,167 @@
+import { useState, useEffect, useContext, useRef, useCallback } from 'react'
+import Link from 'next/link'
+import { UserContext } from '../../../contexts/UserContext'
+import CommentCard from '../CommentCard/CommentCard'
+import Loader from '../../Loader'
+import api from '../../../utils/api'
+import './FunctionComments.css'
+
+const FunctionComments = ({ functionId }) => {
+  // State pour poster un commentaire
+  const { isAuth, user } = useContext(UserContext)
+  const [inputState, setInputState] = useState({})
+
+  // State pour afficher les commentaires
+  const [commentsData, setCommentsData] = useState({ hasMore: true, rows: [] })
+  const [isLoadingComments, setLoadingComments] = useState(true)
+  const [pageComments, setPageComments] = useState(1)
+
+  // Récupère les commentaires si la page change
+  useEffect(() => {
+    getCommentsData().then(data =>
+      setCommentsData({
+        hasMore: data.hasMore,
+        rows: [...commentsData.rows, ...data.rows]
+      })
+    )
+  }, [pageComments])
+
+  // Permet la pagination au scroll
+  const observer = useRef()
+  const lastCommentCardRef = useCallback(
+    node => {
+      if (isLoadingComments) return
+      if (observer.current) observer.current.disconnect()
+      observer.current = new window.IntersectionObserver(
+        entries => {
+          if (entries[0].isIntersecting && commentsData.hasMore) {
+            setPageComments(pageComments + 1)
+          }
+        },
+        { threshold: 1 }
+      )
+      if (node) observer.current.observe(node)
+    },
+    [isLoadingComments, commentsData.hasMore]
+  )
+
+  const getCommentsData = async () => {
+    setLoadingComments(true)
+    const { data } = await api.get(
+      `/comments/${functionId}/?page=${pageComments}&limit=10`
+    )
+    setLoadingComments(false)
+    return data
+  }
+
+  const handleChange = event => {
+    const inputStateNew = { ...inputState }
+    inputStateNew[event.target.name] = event.target.value
+    setInputState(inputStateNew)
+  }
+
+  const handleSubmit = async event => {
+    setLoadingComments(true)
+    event.preventDefault()
+    const token = user.token
+    if (isAuth && token != null && inputState.commentPost != null) {
+      try {
+        const response = await api.post(
+          `/comments/${functionId}`,
+          { message: inputState.commentPost },
+          { headers: { Authorization: token } }
+        )
+        const comment = {
+          ...response.data,
+          user: { name: user.name, logo: user.logo }
+        }
+        setCommentsData({
+          hasMore: commentsData.hasMore,
+          rows: [comment, ...commentsData.rows]
+        })
+        setInputState({ commentPost: '' })
+      } catch {}
+    }
+    setLoadingComments(false)
+  }
+
+  return (
+    <>
+      <div className='FunctionComments__post container-fluid'>
+        <div className='row FunctionComments__row'>
+          <div className='col-24'>
+            {isAuth ? (
+              <form onSubmit={handleSubmit}>
+                <div className='form-group FunctionComments__post-group'>
+                  <label className='form-label' htmlFor='commentPost'>
+                    Ajouter un commentaire :
+                  </label>
+                  <textarea
+                    className='FunctionComments__textarea form-control'
+                    value={inputState.commentPost}
+                    onChange={handleChange}
+                    name='commentPost'
+                    id='commentPost'
+                    placeholder="Idée d'amélioration, avis, remarque, partage d'expérience personnel, ... (Markdown autorisé)"
+                  />
+                </div>
+                <div className='form-group' style={{ marginTop: '0.7em' }}>
+                  <button type='submit' className='btn btn-dark'>
+                    Envoyer
+                  </button>
+                </div>
+              </form>
+            ) : (
+              <p className='text-center'>
+                Vous devez être{' '}
+                <Link href='/users/login'>
+                  <a>connecté</a>
+                </Link>{' '}
+                pour poster un commentaire.
+              </p>
+            )}
+          </div>
+        </div>
+      </div>
+      <div className='container-fluid'>
+        {isLoadingComments && (
+          <div className='row justify-content-center'>
+            <Loader />
+          </div>
+        )}
+        <div className='row justify-content-center'>
+          {commentsData.rows.map((comment, index) => {
+            // Si c'est le dernier élément
+            if (commentsData.rows.length === index + 1) {
+              return (
+                <CommentCard
+                  key={comment.id}
+                  ref={lastCommentCardRef}
+                  {...comment}
+                  manageComment={{
+                    setCommentsData,
+                    commentsData,
+                    setLoadingComments
+                  }}
+                />
+              )
+            }
+            return (
+              <CommentCard
+                key={comment.id}
+                {...comment}
+                manageComment={{
+                  setCommentsData,
+                  commentsData,
+                  setLoadingComments
+                }}
+              />
+            )
+          })}
+        </div>
+      </div>
+    </>
+  )
+}
+
+export default FunctionComments

website/components/FunctionPage/FunctionComponentTop.js

@@ -1,71 +0,0 @@
-import { useState, useEffect, useContext } from 'react';
-import Link from 'next/link';
-import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
-import { faStar } from '@fortawesome/free-solid-svg-icons';
-import { faStar as farStar } from '@fortawesome/free-regular-svg-icons';
-import date from 'date-and-time';
-import { UserContext } from '../../contexts/UserContext';
-import api from '../../utils/api';
-import { API_URL } from '../../utils/config/config';
-import '../FunctionCard/FunctionCard.css';
-
-const FunctionComponentTop = (props) => {
-
-    const { isAuth, user }            = useContext(UserContext);
-    const [isFavorite, setIsFavorite] = useState(false);
-
-    useEffect(() => {
-        if (isAuth && user.token != undefined) {
-            fetchFavorite();
-        }
-    }, [isAuth]);
-
-    const fetchFavorite = async () => {
-        try {
-            const favoriteResponse = await api.get(`/favorites/${props.id}`, { headers: { 'Authorization': user.token } });
-            setIsFavorite(favoriteResponse.data.isFavorite);
-        } catch {}
-    }
-
-    const toggleFavorite = async () => {
-        if (isAuth && user.token != undefined) {
-            try {
-                if (isFavorite) {
-                    const response = await api.delete(`/favorites/${props.id}`, { headers: { 'Authorization': user.token } });
-                    if (response.status === 200) return setIsFavorite(false);
-                }
-                const response = await api.post(`/favorites/${props.id}`, {}, { headers: { 'Authorization': user.token } });
-                if (response.status === 201) return setIsFavorite(true);
-            } catch {}
-        }
-    }
-
-    const handleError = (event) => {
-        event.target.src = API_URL + "/images/functions/default.png";
-    }
-
-    return (
-        <div className="container-fluid">
-            <div className="row justify-content-center text-center">
-                <div className="FunctionComponent__top col-24">
-
-                    {(isAuth) &&
-                        <FontAwesomeIcon onClick={toggleFavorite} { ...(isFavorite) ? { icon: faStar } : { icon: farStar } } title={(isFavorite) ? "Retirer la fonction des favoris" : "Ajouter la fonction aux favoris"} className="FunctionComponent__star-favorite" />
-                    }
-
-                    <img onError={handleError} className="FunctionComponent__image" src={API_URL + props.image} alt={props.title} />
-                    <h1 className="FunctionComponent__title title-important">{props.title}</h1>
-                    <p className="FunctionComponent__description">{props.description}</p>
-                    <div className="FunctionCard__info">
-                        <Link href={`/functions?categoryId=${props.categorieId}`}>
-                            <a className="FunctionCard__category" style={{ backgroundColor: props.categorie.color, color: 'inherit' }}>{props.categorie.name}</a>
-                        </Link>
-                        <p className="FunctionCard__publication-date">{date.format(new Date(props.createdAt), 'DD/MM/YYYY', true)}</p>
-                    </div>
-                </div>
-            </div>
-        </div>
-    );
-}
-
-export default FunctionComponentTop;

website/components/FunctionPage/FunctionComponentTop.jsx

@@ -0,0 +1,102 @@
+import { useState, useEffect, useContext } from 'react'
+import Link from 'next/link'
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'
+import { faStar } from '@fortawesome/free-solid-svg-icons'
+import { faStar as farStar } from '@fortawesome/free-regular-svg-icons'
+import date from 'date-and-time'
+import { UserContext } from '../../contexts/UserContext'
+import api, { API_URL } from '../../utils/api'
+import '../FunctionCard/FunctionCard.css'
+
+const FunctionComponentTop = props => {
+  const { isAuth, user } = useContext(UserContext)
+  const [isFavorite, setIsFavorite] = useState(false)
+
+  useEffect(() => {
+    if (isAuth && user.token != null) {
+      fetchFavorite()
+    }
+  }, [isAuth])
+
+  const fetchFavorite = async () => {
+    try {
+      const favoriteResponse = await api.get(`/favorites/${props.id}`, {
+        headers: { Authorization: user.token }
+      })
+      setIsFavorite(favoriteResponse.data.isFavorite)
+    } catch {}
+  }
+
+  const toggleFavorite = async () => {
+    if (isAuth && user.token != null) {
+      try {
+        if (isFavorite) {
+          const response = await api.delete(`/favorites/${props.id}`, {
+            headers: { Authorization: user.token }
+          })
+          if (response.status === 200) return setIsFavorite(false)
+        }
+        const response = await api.post(
+          `/favorites/${props.id}`,
+          {},
+          { headers: { Authorization: user.token } }
+        )
+        if (response.status === 201) return setIsFavorite(true)
+      } catch {}
+    }
+  }
+
+  const handleError = event => {
+    event.target.src = API_URL + '/images/functions/default.png'
+  }
+
+  return (
+    <div className='container-fluid'>
+      <div className='row justify-content-center text-center'>
+        <div className='FunctionComponent__top col-24'>
+          {isAuth && (
+            <FontAwesomeIcon
+              onClick={toggleFavorite}
+              {...(isFavorite ? { icon: faStar } : { icon: farStar })}
+              title={
+                isFavorite
+                  ? 'Retirer la fonction des favoris'
+                  : 'Ajouter la fonction aux favoris'
+              }
+              className='FunctionComponent__star-favorite'
+            />
+          )}
+
+          <img
+            onError={handleError}
+            className='FunctionComponent__image'
+            src={API_URL + props.image}
+            alt={props.title}
+          />
+          <h1 className='FunctionComponent__title title-important'>
+            {props.title}
+          </h1>
+          <p className='FunctionComponent__description'>{props.description}</p>
+          <div className='FunctionCard__info'>
+            <Link href={`/functions?categoryId=${props.categorieId}`}>
+              <a
+                className='FunctionCard__category'
+                style={{
+                  backgroundColor: props.categorie.color,
+                  color: 'inherit'
+                }}
+              >
+                {props.categorie.name}
+              </a>
+            </Link>
+            <p className='FunctionCard__publication-date'>
+              {date.format(new Date(props.createdAt), 'DD/MM/YYYY', true)}
+            </p>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default FunctionComponentTop

website/components/FunctionPage/FunctionForm.js

@@ -1,161 +0,0 @@
-import { Fragment, useState, useEffect } from 'react';
-import Loader from '../Loader';
-import htmlParser from 'html-react-parser';
-import dynamic from 'next/dynamic';
-import api from '../../utils/api';
-import fr from 'date-fns/locale/fr';
-import { registerLocale } from  "react-datepicker";
-import date from 'date-and-time';
-import "react-datepicker/dist/react-datepicker.css";
-
-registerLocale('fr', fr);
-
-const FunctionForm = (props) => {
-
-    const [inputState, setInputState]         = useState({});
-    const [message, setMessage]               = useState("");
-    const [isLoading, setIsLoading]           = useState(false);
-
-    // inputState par défaut
-    useEffect(() => {
-        const inputStateNew = { ...inputState };
-        props.inputsArray.forEach((input) => {
-            if (input.type === "select" && input.options.length > 0) {
-                inputStateNew[input.name] = input.options[0].value;
-            }
-        });
-        setInputState(inputStateNew);
-    }, []);
-
-    const handleSubmit = (event) => {
-        setIsLoading(true);
-        event.preventDefault();
-        api.post(`/functions/${props.slug}`, inputState)
-            .then((response) => {
-                setMessage(response.data.resultHTML);
-                setIsLoading(false);
-            })
-            .catch((error) => {
-                setMessage(error.response.data.message);
-                setIsLoading(false);
-            });
-    }
-
-    const handleChange = (event) => {
-        const inputStateNew = { ...inputState };
-        inputStateNew[event.target.name] = event.target.value;
-        setInputState(inputStateNew);
-    }
-
-    if (props.inputsArray.length <= 0) {
-        return (
-            <div className="FunctionComponent__slide text-center">
-                <p>La fonction n'est pas encore disponible.</p>
-            </div>
-        );
-    }
-    return (
-        <Fragment>
-            <form onSubmit={handleSubmit}>
-                {props.inputsArray.map((input, index) => {
-                    switch (input.type) {
-                        case "text":
-                            return (
-                                <div key={index} className="form-group">
-                                    <label className="form-label" htmlFor={input.name}>{input.label}</label>
-                                    <input onChange={handleChange} type="text" name={input.name} id={input.name} placeholder={input.placeholder} className="form-control" />
-                                </div>
-                            );
-                        case "integer":
-                        case "float":
-                            return (
-                                <div key={index} className="form-group">
-                                    <label className="form-label" htmlFor={input.name}>{input.label}</label>
-                                    <input onChange={handleChange} type="number" step={(input.type === "integer") ? "1" : "0.01"} name={input.name} id={input.name} placeholder={input.placeholder} className="form-control" />
-                                </div>
-                            );
-                        case "calendar":
-                            // Permet au datepicker de prendre la hauteur
-                            if (typeof window != 'undefined') {
-                                const newScript = document.createElement("script");
-                                newScript.src = "/js/extraHeightCSS.js";
-                                document.body.appendChild(newScript);
-                            }
-                            const DatePicker = dynamic(
-                                () => import('react-datepicker'),
-                                { ssr: false }
-                            );
-                            return (
-                                <div key={index} className="form-group">
-                                    <label className="form-label"  htmlFor={input.name}>{input.label}</label>
-                                    <br/>
-                                    <DatePicker
-                                        selected={(() => {
-                                            try {
-                                                if (inputState[input.name] != undefined) {
-                                                    const dateArray = inputState[input.name].split('/');
-                                                    const year      = dateArray[2];
-                                                    const month     = dateArray[1];
-                                                    const day       = dateArray[0];
-                                                    return new Date(year, parseInt(month) - 1, parseInt(day) + 1);
-                                                }
-                                                throw "Not a valid date";
-                                            } catch { 
-                                                return new Date();
-                                            }
-                                        })()}
-                                        locale="fr"
-                                        dateFormat="dd/MM/yyyy"
-                                        fixedHeight
-                                        placeholderText={input.placeholder}
-                                        onChange={(dateObject) => {
-                                            try {
-                                                const formattedDate = date.format(dateObject, 'DD/MM/YYYY', true);
-                                                handleChange({
-                                                    target: {
-                                                        name: input.name,
-                                                        value: formattedDate
-                                                    }
-                                                });
-                                            } catch {}
-                                        }}
-                                    />
-                                </div>
-                            );
-                        case "select":
-                            return (
-                                <div key={index} className="form-group">
-                                    <label className="form-label" htmlFor={input.name}>{input.label}</label>
-                                    <select onChange={handleChange} name={input.name} id={input.name} value={inputState[input.name] || input.options[0]} className="form-control">
-                                        {input.options.map((option, optionIndex) => {
-                                            return (
-                                                <option key={optionIndex} value={option.value}>{option.name}</option>
-                                            );
-                                        })}
-                                    </select>
-                                </div>
-                            );
-                        default:
-                            return (
-                                <p>Erreur, l'input n'est pas valide...</p>
-                            );
-                    }
-                })}
-                
-                <div className="form-group text-center">
-                    <button type="submit" className="btn btn-dark">Envoyer</button>
-                </div>
-            </form>
-            <div className="form-result text-center">
-                {
-                    (isLoading) ? 
-                        <Loader />
-                    :
-                        htmlParser(message)
-                }
-            </div>
-        </Fragment>
-    );
-}
-
-export default FunctionForm;

website/components/FunctionPage/FunctionForm.jsx

@@ -0,0 +1,195 @@
+import { useState, useEffect } from 'react'
+import Loader from '../Loader'
+import htmlParser from 'html-react-parser'
+import dynamic from 'next/dynamic'
+import api from '../../utils/api'
+import fr from 'date-fns/locale/fr'
+import { registerLocale } from 'react-datepicker'
+import date from 'date-and-time'
+import 'react-datepicker/dist/react-datepicker.css'
+
+registerLocale('fr', fr)
+
+const FunctionForm = props => {
+  const [inputState, setInputState] = useState({})
+  const [message, setMessage] = useState('')
+  const [isLoading, setIsLoading] = useState(false)
+
+  // inputState par défaut
+  useEffect(() => {
+    const inputStateNew = { ...inputState }
+    props.inputsArray.forEach(input => {
+      if (input.type === 'select' && input.options.length > 0) {
+        inputStateNew[input.name] = input.options[0].value
+      }
+    })
+    setInputState(inputStateNew)
+  }, [])
+
+  const handleSubmit = event => {
+    setIsLoading(true)
+    event.preventDefault()
+    api
+      .post(`/functions/${props.slug}`, inputState)
+      .then(response => {
+        setMessage(response.data.resultHTML)
+        setIsLoading(false)
+      })
+      .catch(error => {
+        setMessage(error.response.data.message)
+        setIsLoading(false)
+      })
+  }
+
+  const handleChange = event => {
+    const inputStateNew = { ...inputState }
+    inputStateNew[event.target.name] = event.target.value
+    setInputState(inputStateNew)
+  }
+
+  if (props.inputsArray.length <= 0) {
+    return (
+      <div className='FunctionComponent__slide text-center'>
+        <p>La fonction n'est pas encore disponible.</p>
+      </div>
+    )
+  }
+  return (
+    <>
+      <form onSubmit={handleSubmit}>
+        {props.inputsArray.map((input, index) => {
+          switch (input.type) {
+            case 'text':
+              return (
+                <div key={index} className='form-group'>
+                  <label className='form-label' htmlFor={input.name}>
+                    {input.label}
+                  </label>
+                  <input
+                    onChange={handleChange}
+                    type='text'
+                    name={input.name}
+                    id={input.name}
+                    placeholder={input.placeholder}
+                    className='form-control'
+                  />
+                </div>
+              )
+            case 'integer':
+            case 'float':
+              return (
+                <div key={index} className='form-group'>
+                  <label className='form-label' htmlFor={input.name}>
+                    {input.label}
+                  </label>
+                  <input
+                    onChange={handleChange}
+                    type='number'
+                    step={input.type === 'integer' ? '1' : '0.01'}
+                    name={input.name}
+                    id={input.name}
+                    placeholder={input.placeholder}
+                    className='form-control'
+                  />
+                </div>
+              )
+            case 'calendar':
+              // Permet au datepicker de prendre la hauteur
+              if (typeof window !== 'undefined') {
+                const newScript = document.createElement('script')
+                newScript.src = '/js/extraHeightCSS.js'
+                document.body.appendChild(newScript)
+              }
+              // eslint-disable-next-line
+              const DatePicker = dynamic(() => import('react-datepicker'), {
+                ssr: false
+              })
+              return (
+                <div key={index} className='form-group'>
+                  <label className='form-label' htmlFor={input.name}>
+                    {input.label}
+                  </label>
+                  <br />
+                  <DatePicker
+                    selected={(() => {
+                      try {
+                        if (inputState[input.name] != null) {
+                          const dateArray = inputState[input.name].split('/')
+                          const year = dateArray[2]
+                          const month = dateArray[1]
+                          const day = dateArray[0]
+                          return new Date(
+                            year,
+                            parseInt(month) - 1,
+                            parseInt(day) + 1
+                          )
+                        }
+                        throw new Error('Not a valid date')
+                      } catch {
+                        return new Date()
+                      }
+                    })()}
+                    locale='fr'
+                    dateFormat='dd/MM/yyyy'
+                    fixedHeight
+                    placeholderText={input.placeholder}
+                    onChange={dateObject => {
+                      try {
+                        const formattedDate = date.format(
+                          dateObject,
+                          'DD/MM/YYYY',
+                          true
+                        )
+                        handleChange({
+                          target: {
+                            name: input.name,
+                            value: formattedDate
+                          }
+                        })
+                      } catch {}
+                    }}
+                  />
+                </div>
+              )
+            case 'select':
+              return (
+                <div key={index} className='form-group'>
+                  <label className='form-label' htmlFor={input.name}>
+                    {input.label}
+                  </label>
+                  <select
+                    onChange={handleChange}
+                    name={input.name}
+                    id={input.name}
+                    value={inputState[input.name] || input.options[0]}
+                    className='form-control'
+                  >
+                    {input.options.map((option, optionIndex) => {
+                      return (
+                        <option key={optionIndex} value={option.value}>
+                          {option.name}
+                        </option>
+                      )
+                    })}
+                  </select>
+                </div>
+              )
+            default:
+              return <p>Erreur, l'input n'est pas valide...</p>
+          }
+        })}
+
+        <div className='form-group text-center'>
+          <button type='submit' className='btn btn-dark'>
+            Envoyer
+          </button>
+        </div>
+      </form>
+      <div className='form-result text-center'>
+        {isLoading ? <Loader /> : htmlParser(message)}
+      </div>
+    </>
+  )
+}
+
+export default FunctionForm