@ozdao/prometheus-framework 0.2.129 → 0.2.132

package/src/modules/community/components/sections/Comment.vue

@@ -0,0 +1,123 @@
+<template>
+  <div>
+    <CardHeader 
+      class="mn-b-thin"
+      :entity="comment"
+      :entityType="'comment'"
+      :user="owner"
+      :owner="{target: comment.user}" 
+      :creator="{target: comment.user}"
+      :date="comment.createdAt"
+    />
+    <div class="pd-t-zero">
+      <p class="p-big">{{ comment.content }}</p>
+    </div>
+
+    <div class="mn-t-thin flex-v-center flex-nowrap flex gap-small">
+      
+      <button 
+        v-if="totalReplies > 0" 
+        @click="toggleChildren"
+        class="t-second cursor-pointer t-medium  font-second"
+      >
+        {{ isExpanded ? 'Hide' : totalReplies + (totalReplies === 1 ? ' reply' : ' replies') }} 
+      </button>
+
+      <button 
+        v-if="owner" 
+        class="font-second cursor-pointer t-transp t-medium" 
+        @click="showReplyForm = true"
+      > 
+        Reply
+      </button>
+    
+    </div>
+
+     <div v-if="showReplyForm" class="mn-l-medium mn-t-small bg-white w-100 radius-small pd-small reply-form">
+        <textarea class="w-100" v-model="replyContent"></textarea>
+        <div class="mn-l-auto gap-thin flex-nowrap flex">
+           <button class="bg-grey-transp-25 button" @click="submitReply">Cancel</button>
+          <button class="bg-main button" @click="submitReply">Send</button>
+        </div>
+      </div>
+
+    <div v-if="isExpanded && comment.children && comment.children.length" class="br-solid br-l br-grey-transp-25">
+      <Comment
+        v-for="childComment in comment.children"
+        :key="childComment._id"
+        :comment="childComment"
+        :target="target"
+        :owner="owner"
+        @reply="handleReply"
+        @load-more="handleLoadMore"
+        class="mn-l-medium mn-t-small "
+      />
+    </div>
+   
+  </div>
+</template>
+
+<script setup>
+import { ref, computed } from 'vue';
+
+import Comment from './Comment.vue';
+
+import CardHeader  from '@pf/src/modules/globals/components/blocks/CardHeader.vue'
+
+const props = defineProps({
+  comment: {
+    type: Object,
+    required: true
+  },
+  target: {
+    type: String,
+    required: true
+  },
+  owner: {
+    type: String,
+    required: true
+  }
+});
+
+const emit = defineEmits(['reply', 'load-more']);
+
+const showReplyForm = ref(false);
+const replyContent = ref('');
+const isExpanded = ref(shouldBeExpanded(props.comment.depth))
+
+function shouldBeExpanded(depth) {
+  return depth % 3 < 2
+}
+
+const totalReplies = computed(() => {
+  function countReplies(comment) {
+    if (!comment.children || comment.children.length === 0) {
+      return 0
+    }
+    return comment.children.length + comment.children.reduce((sum, child) => sum + countReplies(child), 0)
+  }
+  return countReplies(props.comment)
+})
+
+const toggleChildren = () => {
+  isExpanded.value = !isExpanded.value
+}
+
+const submitReply = () => {
+  emit('reply', props.comment._id, replyContent.value);
+  replyContent.value = '';
+  showReplyForm.value = false;
+};
+
+const handleReply = (parentId, content) => {
+  emit('reply', parentId, content);
+};
+
+const loadMoreChildren = () => {
+  emit('load-more', props.comment._id, props.comment.depth + 1);
+};
+
+const handleLoadMore = (commentId, depth) => {
+  emit('load-more', commentId, depth);
+};
+</script>

package/src/modules/community/components/sections/Comments.vue

@@ -1,5 +1,5 @@
 <template>
-  <div>
+  <div id="comments">
     <div>
       <h3 class="mn-b-small">{{ comments.length }} comments</h3>
 
@@ -15,21 +15,17 @@
       </div>
     </div>
 
-    <div v-for="comment in comments" :key="comment._id" class="comment mn-b-small radius-big pd-medium bg-light">
-
-      <CardHeader 
-        class="mn-b-medium"
-        :entity="comment"
-        :entityType="'comment'"
-        :user="owner"
-        :owner="{target: comment.user}" 
-        :creator="{target: comment.user}"
-        :date="comment.createdAt"
+     <Comment
+        v-for="comment in comments"
+        :key="comment._id"
+        :comment="comment"
+        :target="target"
+        :type="type"
+        :owner="owner"
+        @reply="handleReply"
+        @load-more="loadMoreChildren"
+        class="comment mn-b-small radius-big pd-medium bg-light"
       />
-      <div class="pd-t-zero">
-        <p class="p-big">{{ comment.content }}</p>
-      </div>
-    </div>
   </div>
 </template>
 
@@ -37,19 +33,94 @@
 import { ref } from 'vue';
 import axios from 'axios';
 
-import CardHeader  from '@pf/src/modules/globals/components/blocks/CardHeader.vue'
+import Comment from './Comment.vue';
 
-const props = defineProps(['target', 'owner', 'type'])
+const props = defineProps([
+  'target', 
+  'owner', 
+  'type'
+])
 
 const $axios = axios.create({ baseURL: process.env.API_URL });
 const comments = ref([]);
 const commentContent = ref('');
 
 const fetchComments = async () => {
-  const { data } = await $axios.get(`/comments/read?type=${props.type}&target=${props.target}&user=${props.owner}`);
-  comments.value = data;
+  try {
+    const response = await axios.get('/comments/read', {
+      params: {
+        target: props.target,
+        type: props.type,
+        user: props.owner,
+        maxDepth: 2
+      }
+    });
+    comments.value = response.data;
+  } catch (error) {
+    console.error('Error fetching comments:', error);
+  }
 };
 
+const handleReply = async (parentId, content) => {
+  try {
+    const response = await axios.post('/comments/create', {
+      content,
+      target: props.target,
+      type: props.type,
+      user: props.owner,
+      parent: parentId
+    });
+
+    const newComment = response.data;
+
+    // Обновляем дерево комментариев
+    updateCommentTree(comments.value, parentId, newComment);
+  } catch (error) {
+    console.error('Error posting reply:', error);
+  }
+};
+
+const loadMoreChildren = async (commentId, depth) => {
+  try {
+    const response = await axios.get('/comments/read', {
+      params: {
+        target: props.target,
+        type: props.type,
+        user: props.owner,
+        parentId: commentId,
+        depth: depth,
+        maxDepth: 10
+      }
+    });
+
+    // Обновляем дерево комментариев
+    updateCommentTree(comments.value, commentId, response.data, response.data.hasMore, true);
+  } catch (error) {
+    console.error('Error loading more comments:', error);
+  }
+};
+
+const updateCommentTree = (comments, parentId, newData, hasMore, isLoadMore = false) => {
+  for (let i = 0; i < comments.length; i++) {
+    if (comments[i]._id === parentId) {
+      if (isLoadMore) {
+        // Для загрузки дополнительных комментариев, добавляем их к существующим
+        comments[i].children = [...comments[i].children, ...newData];
+        comments[i].hasMore = hasMore;
+      } else {
+        // Для нового комментария, добавляем его в начало списка дочерних
+        comments[i].children.push(newData);
+      }
+      return true;
+    }
+    if (comments[i].children && updateCommentTree(comments[i].children, parentId, newData, hasMore, isLoadMore)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+
 const submitComment = async () => {
   if (!commentContent.value) {
     return;

package/src/modules/community/components/sections/HotPosts.vue

@@ -6,10 +6,9 @@
   			Discover Our 
         <router-link 
           :to="{ name:'Blog' }"
-          class="transition-ease-in hover-bg-black hover-t-white transition-timing-1 hover-scale-0 bg-main cursor-pointer pd-thin mn-l-thin radius-extra flex flex-v-center"
+          class="transition-ease-in hover-bg-black hover-t-white transition-timing-1 hover-scale-0 bg-main cursor-pointer pd-thin pd-r-small pd-l-small mn-l-thin radius-extra flex flex-v-center"
         >
            <b>Community</b>
-            <IconArrow class="mn-l-thin radius-extra bg-white i-big"/>
         </router-link>
   		</h2>
 
@@ -21,7 +20,8 @@
           skip: 0,
           limit: 8,
           user: auth.state.user._id,
-          period: 'year'
+          period: 'year',
+          category: 'featured'
         }"
         :text="{
           messages: {
@@ -54,9 +54,6 @@
 	import Feed from '@pf/src/components/Feed/Feed.vue'
 	import Slider from '@pf/src/components/Slider/Slider.vue'
 
-  import IconArrow from '@pf/src/modules/icons/navigation/IconArrow.vue'
-
-
   import CardBlogpost from '@pf/src/modules/community/components/blocks/CardBlogpost.vue';
 	// Import state
 	import * as blog from '@pf/src/modules/community/store/blogposts.js';

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

@@ -58,7 +58,7 @@ const controllerFactory = (db) => {
 			queryProcessorGlobals.getOwnerUserLookupStage(),
 			queryProcessorGlobals.getOwnerOrganizationLookupStage(),
 			queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
-			{ $sample: { size: Number(req.query.limit) } }
+			// { $sample: { size: Number(req.query.limit) } },
 		]
 
 		try {

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;