🎨 standardJS all files

2020-08-03 14:14:45 +02:00
parent dc962c9120
commit 4be7a46a10
85 changed files with 3595 additions and 2383 deletions
--- a/api/routes/admin.js
+++ b/api/routes/admin.js
@ -9,197 +9,215 @@ const AdminRouter = Router()

 AdminRouter.route('/functions')

-// Récupère les fonctions
+  // Récupère les fonctions
  .get(adminController.getFunctions)

-// Permet de créé une fonction
-  .post(fileUpload({
-    useTempFiles: true,
-    safeFileNames: true,
-    preserveExtension: Number,
-    limits: { fileSize: 5 * 1024 * 1024 }, // 5mb,
-    parseNested: true
-  }),
-  [
-    body('title')
-      .not()
-      .isEmpty()
-      .withMessage('La fonction doit avoir un titre.')
-      .isLength({ max: 100 })
-      .withMessage('Le titre est trop long.')
-      .custom((title) => {
-        if (title === 'undefined') {
-          return Promise.reject(new Error('La fonction doit avoir un titre.'))
-        }
-        return true
-      }),
-    body('slug')
-      .not()
-      .isEmpty()
-      .withMessage('La fonction doit avoir un slug.')
-      .isLength({ max: 100 })
-      .withMessage('Le slug est trop long.')
-      .custom((slug) => {
-        if (slug === 'undefined') {
-          return Promise.reject(new Error('La fonction doit avoir un slug.'))
-        }
-        return true
-      })
-      .custom(async (slug) => {
-        try {
-          const FunctionSlug = await Functions.findOne({ where: { slug } })
-          if (FunctionSlug) {
-            return Promise.reject(new Error('Le slug existe déjà...'))
+  // Permet de créé une fonction
+  .post(
+    fileUpload({
+      useTempFiles: true,
+      safeFileNames: true,
+      preserveExtension: Number,
+      limits: { fileSize: 5 * 1024 * 1024 }, // 5mb,
+      parseNested: true
+    }),
+    [
+      body('title')
+        .not()
+        .isEmpty()
+        .withMessage('La fonction doit avoir un titre.')
+        .isLength({ max: 100 })
+        .withMessage('Le titre est trop long.')
+        .custom(title => {
+          if (title === 'undefined') {
+            return Promise.reject(new Error('La fonction doit avoir un titre.'))
          }
-        } catch (error) {
-          console.log(error)
-        }
-        return true
-      }),
-    body('description')
-      .not()
-      .isEmpty()
-      .withMessage('La fonction doit avoir une description.')
-      .isLength({ max: 255, min: 1 })
-      .withMessage('La description est trop longue.')
-      .custom((description) => {
-        if (description === 'undefined') {
-          return Promise.reject(new Error('La fonction doit avoir une description.'))
-        }
-        return true
-      }),
-    body('categorieId')
-      .not()
-      .isEmpty()
-      .withMessage('La fonction doit avoir une catégorie.')
-      .custom(async (categorieId) => {
-        try {
-          const categorieFound = await Categories.findOne({ where: { id: parseInt(categorieId) } })
-          if (!categorieFound) {
-            return Promise.reject(new Error("La catégorie n'existe pas!"))
+          return true
+        }),
+      body('slug')
+        .not()
+        .isEmpty()
+        .withMessage('La fonction doit avoir un slug.')
+        .isLength({ max: 100 })
+        .withMessage('Le slug est trop long.')
+        .custom(slug => {
+          if (slug === 'undefined') {
+            return Promise.reject(new Error('La fonction doit avoir un slug.'))
          }
-        } catch (error) {
-          console.log(error)
-        }
-        return true
-      }),
-    body('type')
-      .custom((type) => {
+          return true
+        })
+        .custom(async slug => {
+          try {
+            const FunctionSlug = await Functions.findOne({ where: { slug } })
+            if (FunctionSlug) {
+              return Promise.reject(new Error('Le slug existe déjà...'))
+            }
+          } catch (error) {
+            console.log(error)
+          }
+          return true
+        }),
+      body('description')
+        .not()
+        .isEmpty()
+        .withMessage('La fonction doit avoir une description.')
+        .isLength({ max: 255, min: 1 })
+        .withMessage('La description est trop longue.')
+        .custom(description => {
+          if (description === 'undefined') {
+            return Promise.reject(
+              new Error('La fonction doit avoir une description.')
+            )
+          }
+          return true
+        }),
+      body('categorieId')
+        .not()
+        .isEmpty()
+        .withMessage('La fonction doit avoir une catégorie.')
+        .custom(async categorieId => {
+          try {
+            const categorieFound = await Categories.findOne({
+              where: { id: parseInt(categorieId) }
+            })
+            if (!categorieFound) {
+              return Promise.reject(new Error("La catégorie n'existe pas!"))
+            }
+          } catch (error) {
+            console.log(error)
+          }
+          return true
+        }),
+      body('type').custom(type => {
        if (!(type === 'article' || type === 'form' || type === 'page')) {
-          return Promise.reject(new Error('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
      })
-  ], adminController.postFunction)
+    ],
+    adminController.postFunction
+  )

 AdminRouter.route('/functions/:slug')

-// Récupère les informations d'une fonction
+  // Récupère les informations d'une fonction
  .get(adminController.getFunctionBySlug)

 AdminRouter.route('/functions/:id')

-// Modifie information basique d'une fonction
-  .put(fileUpload({
-    useTempFiles: true,
-    safeFileNames: true,
-    preserveExtension: Number,
-    limits: { fileSize: 5 * 1024 * 1024 }, // 5mb,
-    parseNested: true
-  }),
-  [
-    body('title')
-      .not()
-      .isEmpty()
-      .withMessage('La fonction doit avoir un titre.')
-      .isLength({ max: 100 })
-      .withMessage('Le titre est trop long.')
-      .custom((title) => {
-        if (title === 'undefined') {
-          return Promise.reject(new Error('La fonction doit avoir un titre.'))
-        }
-        return true
-      }),
-    body('slug')
-      .not()
-      .isEmpty()
-      .withMessage('La fonction doit avoir un slug.')
-      .isLength({ max: 100 })
-      .withMessage('Le slug est trop long.')
-      .custom((slug) => {
-        if (slug === 'undefined') {
-          return Promise.reject(new Error('La fonction doit avoir un slug.'))
-        }
-        return true
-      }),
-    body('description')
-      .not()
-      .isEmpty()
-      .withMessage('La fonction doit avoir une description.')
-      .isLength({ max: 255, min: 1 })
-      .withMessage('La description est trop longue.')
-      .custom((description) => {
-        if (description === 'undefined') {
-          return Promise.reject(new Error('La fonction doit avoir une description.'))
-        }
-        return true
-      }),
-    body('categorieId')
-      .not()
-      .isEmpty()
-      .withMessage('La fonction doit avoir une catégorie.')
-      .custom(async (categorieId) => {
-        try {
-          const categorieFound = await Categories.findOne({ where: { id: parseInt(categorieId) } })
-          if (!categorieFound) {
-            return Promise.reject(new Error("La catégorie n'existe pas!"))
+  // Modifie information basique d'une fonction
+  .put(
+    fileUpload({
+      useTempFiles: true,
+      safeFileNames: true,
+      preserveExtension: Number,
+      limits: { fileSize: 5 * 1024 * 1024 }, // 5mb,
+      parseNested: true
+    }),
+    [
+      body('title')
+        .not()
+        .isEmpty()
+        .withMessage('La fonction doit avoir un titre.')
+        .isLength({ max: 100 })
+        .withMessage('Le titre est trop long.')
+        .custom(title => {
+          if (title === 'undefined') {
+            return Promise.reject(new Error('La fonction doit avoir un titre.'))
          }
-        } catch (error) {
-          console.log(error)
-        }
-        return true
-      }),
-    body('type')
-      .custom((type) => {
+          return true
+        }),
+      body('slug')
+        .not()
+        .isEmpty()
+        .withMessage('La fonction doit avoir un slug.')
+        .isLength({ max: 100 })
+        .withMessage('Le slug est trop long.')
+        .custom(slug => {
+          if (slug === 'undefined') {
+            return Promise.reject(new Error('La fonction doit avoir un slug.'))
+          }
+          return true
+        }),
+      body('description')
+        .not()
+        .isEmpty()
+        .withMessage('La fonction doit avoir une description.')
+        .isLength({ max: 255, min: 1 })
+        .withMessage('La description est trop longue.')
+        .custom(description => {
+          if (description === 'undefined') {
+            return Promise.reject(
+              new Error('La fonction doit avoir une description.')
+            )
+          }
+          return true
+        }),
+      body('categorieId')
+        .not()
+        .isEmpty()
+        .withMessage('La fonction doit avoir une catégorie.')
+        .custom(async categorieId => {
+          try {
+            const categorieFound = await Categories.findOne({
+              where: { id: parseInt(categorieId) }
+            })
+            if (!categorieFound) {
+              return Promise.reject(new Error("La catégorie n'existe pas!"))
+            }
+          } catch (error) {
+            console.log(error)
+          }
+          return true
+        }),
+      body('type').custom(type => {
        if (!(type === 'article' || type === 'form' || type === 'page')) {
-          return Promise.reject(new Error('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
      })
-  ], adminController.putFunction)
+    ],
+    adminController.putFunction
+  )

-// Supprime une fonction avec son id
+  // Supprime une fonction avec son id
  .delete(adminController.deleteFunction)

 AdminRouter.route('/functions/article/:id')
-
  .put(adminController.putFunctionArticle)

 AdminRouter.route('/functions/form/:id')
-
  .put(adminController.putFunctionForm)

 AdminRouter.route('/categories')

-// Crée une catégorie
+  // Crée une catégorie
  .post(adminController.postCategory)

 AdminRouter.route('/categories/:id')

-// Modifier une catégorie avec son id
+  // Modifier une catégorie avec son id
  .put(adminController.putCategory)

-// Supprime une catégorie avec son id
+  // Supprime une catégorie avec son id
  .delete(adminController.deleteCategory)

 AdminRouter.route('/quotes')

-// Récupère les citations pas encore validées
+  // Récupère les citations pas encore validées
  .get(adminController.getQuotes)

 AdminRouter.route('/quotes/:id')

-// Valide ou supprime une citation
+  // Valide ou supprime une citation
  .put(adminController.putQuote)

 module.exports = AdminRouter
--- a/api/routes/categories.js
+++ b/api/routes/categories.js
@ -5,7 +5,7 @@ const CategoriesRouter = Router()

 CategoriesRouter.route('/')

-// Récupère les catégories
+  // Récupère les catégories
  .get(categoriesController.getCategories)

 module.exports = CategoriesRouter
--- a/api/routes/comments.js
+++ b/api/routes/comments.js
@ -6,18 +6,18 @@ const CommentsRouter = Router()

 CommentsRouter.route('/:commentId')

-// Modifier un commentaire
+  // Modifier un commentaire
  .put(isAuth, commentsController.putCommentsById)

-// Supprime un commentaire
+  // Supprime un commentaire
  .delete(isAuth, commentsController.deleteCommentById)

 CommentsRouter.route('/:functionId')

-// Récupère les commentaires
+  // Récupère les commentaires
  .get(commentsController.getCommentsByFunctionId)

-// Permet à un utilisateur de poster un commentaire sur une fonction
+  // Permet à un utilisateur de poster un commentaire sur une fonction
  .post(isAuth, commentsController.postCommentsByFunctionId)

 module.exports = CommentsRouter
--- a/api/routes/favorites.js
+++ b/api/routes/favorites.js
@ -6,13 +6,13 @@ const FavoritesRouter = Router()

 FavoritesRouter.route('/:functionId')

-// Récupère si une fonction est en favoris (d'un utilisateur)
+  // Récupère si une fonction est en favoris (d'un utilisateur)
  .get(isAuth, favoritesController.getFavoriteByFunctionId)

-// Permet à un utilisateur d'ajouter une fonction aux favoris
+  // Permet à un utilisateur d'ajouter une fonction aux favoris
  .post(isAuth, favoritesController.postFavoriteByFunctionId)

-// Supprime une fonction des favoris d'un utilisateur
+  // Supprime une fonction des favoris d'un utilisateur
  .delete(isAuth, favoritesController.deleteFavoriteByFunctionId)

 module.exports = FavoritesRouter
--- a/api/routes/functions.js
+++ b/api/routes/functions.js
@ -5,15 +5,15 @@ const FunctionsRouter = Router()

 FunctionsRouter.route('/')

-// Récupère les fonctions
+  // Récupère les fonctions
  .get(functionsController.getFunctions)

 FunctionsRouter.route('/:slug')

-// Récupère les informations de la fonction par son slug
+  // Récupère les informations de la fonction par son slug
  .get(functionsController.getFunctionBySlug)

-// Exécute la fonction demandée en paramètre
+  // Exécute la fonction demandée en paramètre
  .post(functionsController.executeFunctionBySlug)

 module.exports = FunctionsRouter
--- a/api/routes/quotes.js
+++ b/api/routes/quotes.js
@ -6,10 +6,10 @@ const QuotesRouter = Router()

 QuotesRouter.route('/')

-// Récupère les citations
+  // Récupère les citations
  .get(quotesController.getQuotes)

-// Proposer une citation
+  // Proposer une citation
  .post(isAuth, quotesController.postQuote)

 module.exports = QuotesRouter
--- a/api/routes/tasks.js
+++ b/api/routes/tasks.js
@ -6,18 +6,18 @@ const TasksRouter = Router()

 TasksRouter.route('/')

-// Récupère les tâches à faire d'un user
+  // Récupère les tâches à faire d'un user
  .get(isAuth, tasksController.getTasks)

-// Poster une nouvelle tâche à faire
+  // Poster une nouvelle tâche à faire
  .post(isAuth, tasksController.postTask)

 TasksRouter.route('/:id')

-// Permet de mettre une tâche à faire en isCompleted ou !isCompleted
+  // Permet de mettre une tâche à faire en isCompleted ou !isCompleted
  .put(isAuth, tasksController.putTask)

-// Supprimer une tâche à faire
+  // Supprimer une tâche à faire
  .delete(isAuth, tasksController.deleteTask)

 module.exports = TasksRouter