@ozdao/prometheus-framework 0.2.130 → 0.2.132

package/src/modules/community/controllers/comments.controller.aggr.js

@@ -0,0 +1,280 @@
+const commentControllerFactory = (db) => {
+  const Comment = db.comment;
+  const Membership = db.membership;
+
+  const read = async (req, res) => {
+    try {
+      const { target, type, user, maxDepth = 4, parentId = null } = req.query;
+      
+      let conditions = {
+        target: new db.mongoose.Types.ObjectId(target),
+        type: type,
+      };
+      
+      if (parentId) {
+        conditions.parent = new db.mongoose.Types.ObjectId(parentId);
+      } else {
+        conditions.parent = null;
+      }
+
+      let blockedMembers = [];
+
+      if (user) {
+        const memberships = await Membership.find({ user: user, role: 'blocked' });
+        blockedMembers = memberships.map(membership => membership.target);
+      }
+
+      const pipeline = [
+        { $match: conditions },
+        { $sort: { createdAt: -1 } },
+        {
+          $graphLookup: {
+            from: 'comments',
+            startWith: '$_id',
+            connectFromField: '_id',
+            connectToField: 'parent',
+            as: 'allChildren',
+            depthField: 'childDepth',
+            maxDepth: 2
+          }
+        },
+        {
+          $lookup: {
+            from: 'users',
+            localField: 'user',
+            foreignField: '_id',
+            as: 'user'
+          }
+        },
+        { $unwind: '$user' },
+        {
+          $lookup: {
+            from: 'users',
+            localField: 'allChildren.user',
+            foreignField: '_id',
+            as: 'childUsers'
+          }
+        },
+        {
+          $addFields: {
+            childrenCount: {
+              $size: {
+                $filter: {
+                  input: '$allChildren',
+                  as: 'child',
+                  cond: { $eq: ['$$child.parent', '$_id'] }
+                }
+              }
+            }
+          }
+        },
+        {
+          $addFields: {
+            children: {
+              $map: {
+                input: {
+                  $filter: {
+                    input: '$allChildren',
+                    as: 'child',
+                    cond: { $eq: ['$$child.childDepth', 0] }
+                  }
+                },
+                as: 'child',
+                in: {
+                  $mergeObjects: [
+                    '$$child',
+                    {
+                      user: {$arrayElemAt: [{$filter: {input: '$childUsers', as: 'childUser', cond: { $eq: ['$$childUser._id', '$$child.user'] } } }, 0 ] },
+                      childrenCount: {$size: {$filter: {input: '$allChildren', as: 'grandchild', cond: { $eq: ['$$grandchild.parent', '$$child._id'] } } } },
+                      children: {
+                        $map: {
+                          input: {
+                            $filter: {
+                              input: '$allChildren',
+                              as: 'grandchild',
+                              cond: { $eq: ['$$grandchild.parent', '$$child._id'] }
+                            }
+                          },
+                          as: 'grandchild',
+                          in: {
+                            $mergeObjects: [
+                              '$$grandchild',
+                              {
+                                user: {$arrayElemAt: [{$filter: {input: '$childUsers', as: 'childUser', cond: { $eq: ['$$childUser._id', '$$grandchild.user'] } } }, 0 ] },
+                                childrenCount: {$size: {$filter: {input: '$allChildren', as: 'greatgrandchild', cond: { $eq: ['$$greatgrandchild.parent', '$$grandchild._id'] } } } },
+                                hasMore: {$cond: {if: {$gt: [{$size: {$filter: {input: '$allChildren', as: 'greatgrandchild', cond: { $eq: ['$$greatgrandchild.parent', '$$grandchild._id'] } } } }, 0 ] }, then: true, else: false } }
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        },
+        {
+          $project: {
+            _id: 1,
+            content: 1,
+            type: 1,
+            target: 1,
+            'user.username': 1,
+            'user.profile.photo': 1,
+            'user.profile.name': 1,
+            'user._id': 1,
+            depth: 1,
+            createdAt: 1,
+            childrenCount: 1,
+            children: 1
+          }
+        }
+      ];
+
+      if (blockedMembers.length > 0) {
+        pipeline.unshift({ $match: { user: { $nin: blockedMembers } } });
+      }
+
+      const comments = await Comment.aggregate(pipeline);
+
+      function buildCommentTree(comments) {
+        // Создаем Map для быстрого доступа ко всем комментариям по их ID
+        const commentMap = new Map();
+        
+        // Функция для преобразования MongoDB ObjectId в строку
+        const objectIdToString = (id) => id.toString();
+
+        // Функция для добавления комментария и его дочерних элементов в Map
+        function addToMap(comment) {
+          const commentId = objectIdToString(comment._id);
+          if (!commentMap.has(commentId)) {
+            commentMap.set(commentId, {...comment, children: []});
+            if (comment.children && comment.children.length > 0) {
+              comment.children.forEach(addToMap);
+            }
+          }
+        }
+
+        // Добавляем все комментарии и их дочерние элементы в Map
+        comments.forEach(addToMap);
+
+        // Строим дерево
+        commentMap.forEach((comment) => {
+          if (comment.parent) {
+            const parentId = objectIdToString(comment.parent);
+            const parent = commentMap.get(parentId);
+            if (parent) {
+              parent.children.push(comment);
+            }
+          }
+        });
+
+        // Возвращаем только корневые комментарии
+        return comments.map(comment => {
+          const commentId = objectIdToString(comment._id);
+          return commentMap.get(commentId);
+        });
+      }
+
+
+      commentsTree = buildCommentTree(comments)
+
+      console.log(commentsTree)
+
+      res.status(200).json(commentsTree);
+    } catch (error) {
+      console.error(error);
+      res.status(500).json({ message: error.message });
+    }
+  };
+
+
+  const create = async (req, res) => {
+    try {
+      const { user, type, target, content, parent } = req.body;
+
+      let depth = 0;
+      
+      if (parent) {
+        const parentComment = await Comment.findById(parent);
+        if (!parentComment) {
+          return res.status(404).send({ message: "Parent comment not found." });
+        }
+        depth = parentComment.depth + 1;
+      }
+
+      const comment = new Comment({
+        user,
+        type,
+        target,
+        content,
+        parent,
+        depth
+      });
+
+      const savedComment = await comment.save();
+
+      if (parent) {
+        await Comment.findByIdAndUpdate(parent, {
+          $push: { children: savedComment._id }
+        });
+      }
+
+      const populatedComment = await Comment.findById(savedComment._id)
+        .populate({
+          path: 'user',
+          select: 'username profile.photo profile.name _id'
+        })
+
+      res.status(201).send(populatedComment);
+    } catch (err) {
+      console.error(err);
+      res.status(500).send({
+        message: err.message || "Some error occurred while creating the comment."
+      });
+    }
+  };
+
+  const update = async (req, res) => {
+    try {
+      const comment = await Comment.findByIdAndUpdate(req.params._id, req.body, { new: true })
+        .populate({
+          path: 'user',
+          select: 'username profile.photo profile.name _id'
+        });
+
+      if (!comment) {
+        return res.status(404).send({ message: "Comment not found." });
+      }
+
+      res.status(200).send(comment);
+    } catch (err) {
+      res.status(500).send({ message: err.message });
+    }
+  };
+
+  const deleteComment = async (req, res) => {
+    try {
+      const comment = await Comment.findByIdAndRemove(req.params._id);
+
+      if (!comment) {
+        return res.status(404).send({ message: "Comment is not deleted." });
+      }
+
+      res.status(200).send(comment);
+    } catch (err) {
+      res.status(500).send({ message: err.message });
+    }
+  };
+
+  return {
+    read,
+    create,
+    update,
+    delete: deleteComment
+  };
+};
+
+module.exports = commentControllerFactory;

package/src/modules/community/controllers/comments.controller.js

@@ -1,66 +1,215 @@
 const commentControllerFactory = (db) => {
   const Comment = db.comment;
-   const Membership = db.membership;
+  const Membership = db.membership;
 
   const read = async (req, res) => {
     try {
-      let conditions = { target: req.query.target }; // базовое условие для поиска комментариев
-
-      // Если в запросе есть пользователь, мы исключаем комментарии от заблокированных пользователей
-      if (req.query.user) {
-        const memberships = await Membership.find({ user: req.query.user });
-        const blockedMembers = memberships
-          .filter(membership => membership.role === 'blocked')
-          .map(membership => membership.target);
-
-        // Если есть заблокированные пользователи, добавляем условие в запрос
-        if (blockedMembers.length > 0) {
-          conditions.user = { "$nin": blockedMembers }; // добавляем условие, исключающее заблокированных пользователей
-        }
+      const { target, type, user, maxDepth = 4, parentId = null } = req.query;
+      
+      let conditions = {
+        target: new db.mongoose.Types.ObjectId(target),
+        type: type,
+      };
+      
+      if (parentId) {
+        conditions.parent = new db.mongoose.Types.ObjectId(parentId);
+      } else {
+        conditions.parent = null;
       }
 
-      // Теперь мы добавили условия, исключающие комментарии от заблокированных пользователей, в наш запрос.
-      const comments = await Comment.find(conditions)
-        .populate({
-          path: 'user',
-          select: 'username profile.photo profile.name _id'
+      let blockedMembers = [];
+
+      if (user) {
+        const memberships = await Membership.find({ user: user, role: 'blocked' });
+        blockedMembers = memberships.map(membership => membership.target);
+      }
+
+      const pipeline = [
+        { $match: conditions },
+        { $sort: { createdAt: 1 } },
+        {
+          $graphLookup: {
+            from: 'comments',
+            startWith: '$_id',
+            connectFromField: '_id',
+            connectToField: 'parent',
+            as: 'children',
+            depthField: 'childDepth'
+          }
+        },
+        {
+          $lookup: {
+            from: 'users',
+            localField: 'user',
+            foreignField: '_id',
+            as: 'user'
+          }
+        },
+        { $unwind: '$user' },
+        {
+          $lookup: {
+            from: 'users',
+            localField: 'children.user',
+            foreignField: '_id',
+            as: 'childUsers'
+          }
+        },
+        {
+          $project: {
+            _id: 1,
+            content: 1,
+            type: 1,
+            target: 1,
+            'user.username': 1,
+            'user.profile.photo': 1,
+            'user.profile.name': 1,
+            'user._id': 1,
+            depth: 1,
+            createdAt: 1,
+            childrenCount: { $size: '$children' },
+            children: {
+              $map: {
+                input: '$children',
+                as: 'child',
+                in: {
+                  _id: '$$child._id',
+                  content: '$$child.content',
+                  type: '$$child.type',
+                  parent: '$$child.parent',
+                  target: '$$child.target',
+                  user: {
+                    $arrayElemAt: [
+                      {
+                        $filter: {
+                          input: '$childUsers',
+                          as: 'childUser',
+                          cond: { $eq: ['$$childUser._id', '$$child.user'] }
+                        }
+                      },
+                      0
+                    ]
+                  },
+                  depth: '$$child.depth',
+                  createdAt: '$$child.createdAt',
+                  childrenCount: { $size: '$$child.children' }
+                }
+              }
+            }
+          }
+        },
+      ];
+
+      if (blockedMembers.length > 0) {
+        pipeline.unshift({ $match: { user: { $nin: blockedMembers } } });
+      }
+
+      const comments = await Comment.aggregate(pipeline);
+
+      function buildCommentTree(comments) {
+        // Создаем Map для быстрого доступа ко всем комментариям по их ID
+        const commentMap = new Map();
+        
+        // Функция для преобразования MongoDB ObjectId в строку
+        const objectIdToString = (id) => id.toString();
+
+        // Функция для добавления комментария и его дочерних элементов в Map
+        function addToMap(comment) {
+          const commentId = objectIdToString(comment._id);
+          if (!commentMap.has(commentId)) {
+            commentMap.set(commentId, {...comment, children: []});
+            if (comment.children && comment.children.length > 0) {
+              comment.children.forEach(addToMap);
+            }
+          }
+        }
+
+        // Добавляем все комментарии и их дочерние элементы в Map
+        comments.forEach(addToMap);
+
+        // Строим дерево
+        commentMap.forEach((comment) => {
+          if (comment.parent) {
+            const parentId = objectIdToString(comment.parent);
+            const parent = commentMap.get(parentId);
+            if (parent) {
+              parent.children.push(comment);
+            }
+          }
         });
 
-      if (!comments) {
-        return res.status(404).send({ message: "Comments not found." });
+        // Функция для рекурсивной сортировки дочерних комментариев
+        function sortChildren(comment) {
+          if (comment.children.length > 0) {
+            comment.children.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+            comment.children.forEach(sortChildren);
+          }
+        }
+
+        // Получаем корневые комментарии и сортируем их
+        const rootComments = comments.map(comment => {
+          const commentId = objectIdToString(comment._id);
+          return commentMap.get(commentId);
+        }).filter(comment => !comment.parent);
+
+        // Сортируем корневые комментарии по createdAt
+        rootComments.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+
+        // Рекурсивно сортируем дочерние комментарии
+        rootComments.forEach(sortChildren);
+
+        return rootComments;
       }
 
-      const countedComments = comments.map(comment => {
-        return {
-          ...comment._doc,
-          user: comment.user,
-        };
-      });
+      commentsTree = buildCommentTree(comments)
 
-      res.status(200).send(countedComments);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
+      console.log(commentsTree)
+
+      res.status(200).json(commentsTree);
+    } catch (error) {
+      console.error(error);
+      res.status(500).json({ message: error.message });
     }
   };
 
 
   const create = async (req, res) => {
     try {
+      const { user, type, target, content, parent } = req.body;
+
+      let depth = 0;
+      
+      if (parent) {
+        const parentComment = await Comment.findById(parent);
+        if (!parentComment) {
+          return res.status(404).send({ message: "Parent comment not found." });
+        }
+        depth = parentComment.depth + 1;
+      }
+
       const comment = new Comment({
-        user: req.body.user,
-        type: req.body.type,
-        target: req.body.target,
-        content: req.body.content
+        user,
+        type,
+        target,
+        content,
+        parent,
+        depth
       });
 
-      const data = await comment.save();
-      const populatedComment = await Comment.findOne({ _id: data._id })
+      const savedComment = await comment.save();
+
+      if (parent) {
+        await Comment.findByIdAndUpdate(parent, {
+          $push: { children: savedComment._id }
+        });
+      }
+
+      const populatedComment = await Comment.findById(savedComment._id)
         .populate({
           path: 'user',
           select: 'username profile.photo profile.name _id'
-        });
+        })
 
-      res.status(200).send(populatedComment);
+      res.status(201).send(populatedComment);
     } catch (err) {
       console.error(err);
       res.status(500).send({