refactor createmenutree

src/controllers/pagesOrder.js

@@ -23,6 +23,15 @@ class PagesOrder {
     return order;
   }
 
+  /**
+   * Returns all records about page's order
+   *
+   * @returns {Promise<PagesOrder[]>}
+   */
+  static async getAll() {
+    return Model.getAll();
+  }
+
   /**
    * Pushes the child page to the parent's order list
    *

src/models/pageOrder.js

@@ -34,6 +34,19 @@ class PageOrder {
     return new PageOrder(data);
   }
 
+  /**
+   * Find all pages which match passed query object
+   *
+   * @param {Object} query
+   * @returns {Promise<Page[]>}
+   */
+  static async getAll(query = {}) {
+    const docs = await db.find(query);
+
+    return Promise.all(docs.map(doc => new PageOrder(doc)));
+  }
+
+
   /**
    * @constructor
    *

src/routes/middlewares/pages.js

@@ -4,44 +4,48 @@ const asyncMiddleware = require('../../utils/asyncMiddleware');
 
 /**
  * Process one-level pages list to parent-children list
- * @param {string[]} pages - list of all available pages
+ *
+ * @param {string} parentPageId - parent page id
+ * @param {Page[]} pages - list of all available pages
+ * @param {PagesOrder[]} pagesOrder - list of pages order
  * @param {number} level
  * @param {number} currentLevel
  *
  * @return {Page[]}
  */
-async function createMenuTree(pages, level = 1, currentLevel = 1) {
+function createMenuTree(parentPageId, pages, pagesOrder, level = 1, currentLevel = 1) {
-  return await Promise.all(pages.map(async pageId => {
+  let childrenOrder = pagesOrder.find(order => order.data.page === parentPageId);
-    const parent = await Pages.get(pageId);
 
-    /**
+  /**
-     * By default we accept that deepestChildren is empty Array
+   * branch is a page children in tree
-     * @type {Array}
+   * if we got some children order on parents tree, then we push found pages in order sequence
-     */
+   * otherwise just find all pages includes parent tree
-    let deepestChildren = [];
+   */
+  let branch = [];
+  if (childrenOrder) {
+    branch = childrenOrder.order.map( pageId => {
+      return pages.find( page => page._id === pageId);
+    });
+  } else {
+    branch = pages.filter( page => page._parent === parentPageId);
+  }
 
-    /**
+  /**
-     * Here we try to check parent's children order
+   * stop recursion when we got the passed max level
-     * If we got something, pluck to found Page deeper and get its children order
+   */
-     */
+  if (currentLevel === level + 1) {
-    try {
+    return [];
-      /**
+  }
-       * Go deeper until we didn't get the deepest level
-       * On each 'currentLevel' create new Menu Tree with ordered Page ids
-       */
-      if (currentLevel !== level) {
-        const children = await PagesOrder.get(pageId);
-        deepestChildren = await createMenuTree(children.order, level, currentLevel + 1)
-      }
-    } catch (e) {}
 
-    /**
+  /**
-     * Assign parent's children with found Menu Tree
+   * Each parents children can have subbranches
-     */
+   */
+  return branch.filter(page => page && page._id).map( page => {
     return Object.assign({
-      children: deepestChildren
+      children: createMenuTree(page._id, pages, pagesOrder, level, currentLevel + 1)
-    }, parent.data);
+    }, page.data);
-  }));
+  });
+
 }
 
 /**
@@ -57,8 +61,9 @@ module.exports = asyncMiddleware(async function (req, res, next) {
    */
   const parentIdOfRootPages = '0';
   try {
-    const rootPages = await PagesOrder.get(parentIdOfRootPages);
+    const pages = await Pages.getAll();
-    res.locals.menu = await createMenuTree(rootPages.order, 2);
+    const pagesOrder = await PagesOrder.getAll();
+    res.locals.menu = createMenuTree(parentIdOfRootPages, pages, pagesOrder, 2);
   } catch (error) {
     console.log('Can not load menu:', error);
   }